1
2
3
4
5
6
7 import _Piavca_base
8 import new
9 new_instancemethod = new.instancemethod
10 try:
11 _swig_property = property
12 except NameError:
13 pass
15 if (name == "thisown"): return self.this.own(value)
16 if (name == "this"):
17 if type(value).__name__ == 'PySwigObject':
18 self.__dict__[name] = value
19 return
20 method = class_type.__swig_setmethods__.get(name,None)
21 if method: return method(self,value)
22 if (not static) or hasattr(self,name):
23 self.__dict__[name] = value
24 else:
25 raise AttributeError("You cannot add attributes to %s" % self)
26
29
31 if (name == "thisown"): return self.this.own()
32 method = class_type.__swig_getmethods__.get(name,None)
33 if method: return method(self)
34 raise AttributeError,name
35
37 try: strthis = "proxy of " + self.this.__repr__()
38 except: strthis = ""
39 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
40
41 import types
42 try:
43 _object = types.ObjectType
44 _newclass = 1
45 except AttributeError:
47 _newclass = 0
48 del types
49
50
51 try:
52 import weakref
53 weakref_proxy = weakref.proxy
54 except:
55 weakref_proxy = lambda x: x
56
57
59 __swig_setmethods__ = {}
60 __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
61 __swig_getmethods__ = {}
62 __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
63 - def __init__(self): raise AttributeError, "No constructor defined"
64 __repr__ = _swig_repr
65 __swig_destroy__ = _Piavca_base.delete_PySwigIterator
66 __del__ = lambda self : None;
67 - def value(*args): return _Piavca_base.PySwigIterator_value(*args)
68 - def incr(*args): return _Piavca_base.PySwigIterator_incr(*args)
69 - def decr(*args): return _Piavca_base.PySwigIterator_decr(*args)
70 - def distance(*args): return _Piavca_base.PySwigIterator_distance(*args)
71 - def equal(*args): return _Piavca_base.PySwigIterator_equal(*args)
72 - def copy(*args): return _Piavca_base.PySwigIterator_copy(*args)
73 - def next(*args): return _Piavca_base.PySwigIterator_next(*args)
74 - def previous(*args): return _Piavca_base.PySwigIterator_previous(*args)
75 - def advance(*args): return _Piavca_base.PySwigIterator_advance(*args)
76 - def __eq__(*args): return _Piavca_base.PySwigIterator___eq__(*args)
77 - def __ne__(*args): return _Piavca_base.PySwigIterator___ne__(*args)
78 - def __iadd__(*args): return _Piavca_base.PySwigIterator___iadd__(*args)
79 - def __isub__(*args): return _Piavca_base.PySwigIterator___isub__(*args)
80 - def __add__(*args): return _Piavca_base.PySwigIterator___add__(*args)
81 - def __sub__(*args): return _Piavca_base.PySwigIterator___sub__(*args)
83 PySwigIterator_swigregister = _Piavca_base.PySwigIterator_swigregister
84 PySwigIterator_swigregister(PySwigIterator)
85
87 __swig_setmethods__ = {}
88 __setattr__ = lambda self, name, value: _swig_setattr(self, vectorS, name, value)
89 __swig_getmethods__ = {}
90 __getattr__ = lambda self, name: _swig_getattr(self, vectorS, name)
91 __repr__ = _swig_repr
92 - def iterator(*args): return _Piavca_base.vectorS_iterator(*args)
94 - def __nonzero__(*args): return _Piavca_base.vectorS___nonzero__(*args)
95 - def __len__(*args): return _Piavca_base.vectorS___len__(*args)
96 - def pop(*args): return _Piavca_base.vectorS_pop(*args)
97 - def __getslice__(*args): return _Piavca_base.vectorS___getslice__(*args)
98 - def __setslice__(*args): return _Piavca_base.vectorS___setslice__(*args)
99 - def __delslice__(*args): return _Piavca_base.vectorS___delslice__(*args)
100 - def __delitem__(*args): return _Piavca_base.vectorS___delitem__(*args)
101 - def __getitem__(*args): return _Piavca_base.vectorS___getitem__(*args)
102 - def __setitem__(*args): return _Piavca_base.vectorS___setitem__(*args)
103 - def append(*args): return _Piavca_base.vectorS_append(*args)
104 - def empty(*args): return _Piavca_base.vectorS_empty(*args)
105 - def size(*args): return _Piavca_base.vectorS_size(*args)
106 - def clear(*args): return _Piavca_base.vectorS_clear(*args)
107 - def swap(*args): return _Piavca_base.vectorS_swap(*args)
108 - def get_allocator(*args): return _Piavca_base.vectorS_get_allocator(*args)
109 - def begin(*args): return _Piavca_base.vectorS_begin(*args)
110 - def end(*args): return _Piavca_base.vectorS_end(*args)
111 - def rbegin(*args): return _Piavca_base.vectorS_rbegin(*args)
112 - def rend(*args): return _Piavca_base.vectorS_rend(*args)
113 - def pop_back(*args): return _Piavca_base.vectorS_pop_back(*args)
114 - def erase(*args): return _Piavca_base.vectorS_erase(*args)
116 this = _Piavca_base.new_vectorS(*args)
117 try: self.this.append(this)
118 except: self.this = this
119 - def push_back(*args): return _Piavca_base.vectorS_push_back(*args)
120 - def front(*args): return _Piavca_base.vectorS_front(*args)
121 - def back(*args): return _Piavca_base.vectorS_back(*args)
122 - def assign(*args): return _Piavca_base.vectorS_assign(*args)
123 - def resize(*args): return _Piavca_base.vectorS_resize(*args)
124 - def insert(*args): return _Piavca_base.vectorS_insert(*args)
125 - def reserve(*args): return _Piavca_base.vectorS_reserve(*args)
126 - def capacity(*args): return _Piavca_base.vectorS_capacity(*args)
127 __swig_destroy__ = _Piavca_base.delete_vectorS
128 __del__ = lambda self : None;
129 vectorS_swigregister = _Piavca_base.vectorS_swigregister
130 vectorS_swigregister(vectorS)
131
133 __swig_setmethods__ = {}
134 __setattr__ = lambda self, name, value: _swig_setattr(self, vectorI, name, value)
135 __swig_getmethods__ = {}
136 __getattr__ = lambda self, name: _swig_getattr(self, vectorI, name)
137 __repr__ = _swig_repr
138 - def iterator(*args): return _Piavca_base.vectorI_iterator(*args)
140 - def __nonzero__(*args): return _Piavca_base.vectorI___nonzero__(*args)
141 - def __len__(*args): return _Piavca_base.vectorI___len__(*args)
142 - def pop(*args): return _Piavca_base.vectorI_pop(*args)
143 - def __getslice__(*args): return _Piavca_base.vectorI___getslice__(*args)
144 - def __setslice__(*args): return _Piavca_base.vectorI___setslice__(*args)
145 - def __delslice__(*args): return _Piavca_base.vectorI___delslice__(*args)
146 - def __delitem__(*args): return _Piavca_base.vectorI___delitem__(*args)
147 - def __getitem__(*args): return _Piavca_base.vectorI___getitem__(*args)
148 - def __setitem__(*args): return _Piavca_base.vectorI___setitem__(*args)
149 - def append(*args): return _Piavca_base.vectorI_append(*args)
150 - def empty(*args): return _Piavca_base.vectorI_empty(*args)
151 - def size(*args): return _Piavca_base.vectorI_size(*args)
152 - def clear(*args): return _Piavca_base.vectorI_clear(*args)
153 - def swap(*args): return _Piavca_base.vectorI_swap(*args)
154 - def get_allocator(*args): return _Piavca_base.vectorI_get_allocator(*args)
155 - def begin(*args): return _Piavca_base.vectorI_begin(*args)
156 - def end(*args): return _Piavca_base.vectorI_end(*args)
157 - def rbegin(*args): return _Piavca_base.vectorI_rbegin(*args)
158 - def rend(*args): return _Piavca_base.vectorI_rend(*args)
159 - def pop_back(*args): return _Piavca_base.vectorI_pop_back(*args)
160 - def erase(*args): return _Piavca_base.vectorI_erase(*args)
162 this = _Piavca_base.new_vectorI(*args)
163 try: self.this.append(this)
164 except: self.this = this
165 - def push_back(*args): return _Piavca_base.vectorI_push_back(*args)
166 - def front(*args): return _Piavca_base.vectorI_front(*args)
167 - def back(*args): return _Piavca_base.vectorI_back(*args)
168 - def assign(*args): return _Piavca_base.vectorI_assign(*args)
169 - def resize(*args): return _Piavca_base.vectorI_resize(*args)
170 - def insert(*args): return _Piavca_base.vectorI_insert(*args)
171 - def reserve(*args): return _Piavca_base.vectorI_reserve(*args)
172 - def capacity(*args): return _Piavca_base.vectorI_capacity(*args)
173 __swig_destroy__ = _Piavca_base.delete_vectorI
174 __del__ = lambda self : None;
175 vectorI_swigregister = _Piavca_base.vectorI_swigregister
176 vectorI_swigregister(vectorI)
177
178 GetAvatarPointer = _Piavca_base.GetAvatarPointer
179 GetPiavcaCorePointer = _Piavca_base.GetPiavcaCorePointer
189 __swig_destroy__ = _Piavca_base.delete_Vec
190 __del__ = lambda self : None;
191 - def X(*args): return _Piavca_base.Vec_X(*args)
192 - def Y(*args): return _Piavca_base.Vec_Y(*args)
193 - def Z(*args): return _Piavca_base.Vec_Z(*args)
194 __swig_getmethods__["XAxis"] = lambda x: _Piavca_base.Vec_XAxis
195 if _newclass:XAxis = staticmethod(_Piavca_base.Vec_XAxis)
196 __swig_getmethods__["YAxis"] = lambda x: _Piavca_base.Vec_YAxis
197 if _newclass:YAxis = staticmethod(_Piavca_base.Vec_YAxis)
198 __swig_getmethods__["ZAxis"] = lambda x: _Piavca_base.Vec_ZAxis
199 if _newclass:ZAxis = staticmethod(_Piavca_base.Vec_ZAxis)
200 - def mag(*args): return _Piavca_base.Vec_mag(*args)
201 - def __add__(*args): return _Piavca_base.Vec___add__(*args)
202 - def __iadd__(*args): return _Piavca_base.Vec___iadd__(*args)
203 - def __sub__(*args): return _Piavca_base.Vec___sub__(*args)
204 - def __isub__(*args): return _Piavca_base.Vec___isub__(*args)
205 - def __neg__(*args): return _Piavca_base.Vec___neg__(*args)
206 - def __mul__(*args): return _Piavca_base.Vec___mul__(*args)
207 - def __imul__(*args): return _Piavca_base.Vec___imul__(*args)
208 - def __div__(*args): return _Piavca_base.Vec___div__(*args)
209 - def __idiv__(*args): return _Piavca_base.Vec___idiv__(*args)
210 - def __eq__(*args): return _Piavca_base.Vec___eq__(*args)
211 - def __ne__(*args): return _Piavca_base.Vec___ne__(*args)
212 - def inverse(*args): return _Piavca_base.Vec_inverse(*args)
213 - def invert(*args): return _Piavca_base.Vec_invert(*args)
214 - def dot(*args): return _Piavca_base.Vec_dot(*args)
215 - def cross(*args): return _Piavca_base.Vec_cross(*args)
216 - def crossinplace(*args): return _Piavca_base.Vec_crossinplace(*args)
217 - def normalized(*args): return _Piavca_base.Vec_normalized(*args)
218 - def normalize(*args): return _Piavca_base.Vec_normalize(*args)
219 - def __getitem__(*args): return _Piavca_base.Vec___getitem__(*args)
220 - def __setitem__(*args): return _Piavca_base.Vec___setitem__(*args)
221 - def __repr__(*args): return _Piavca_base.Vec___repr__(*args)
222 Vec_swigregister = _Piavca_base.Vec_swigregister
223 Vec_swigregister(Vec)
224 Vec_XAxis = _Piavca_base.Vec_XAxis
225 Vec_YAxis = _Piavca_base.Vec_YAxis
226 Vec_ZAxis = _Piavca_base.Vec_ZAxis
227
228 -class Quat(_object):
237 __swig_destroy__ = _Piavca_base.delete_Quat
238 __del__ = lambda self : None;
239 - def S(*args): return _Piavca_base.Quat_S(*args)
240 - def I(*args): return _Piavca_base.Quat_I(*args)
241 - def J(*args): return _Piavca_base.Quat_J(*args)
242 - def K(*args): return _Piavca_base.Quat_K(*args)
243 - def setAngleAxis(*args): return _Piavca_base.Quat_setAngleAxis(*args)
244 - def getAngleAxis(*args): return _Piavca_base.Quat_getAngleAxis(*args)
245 - def getAngle(*args): return _Piavca_base.Quat_getAngle(*args)
246 - def getAxis(*args): return _Piavca_base.Quat_getAxis(*args)
247 - def getEulerAngles(*args): return _Piavca_base.Quat_getEulerAngles(*args)
248 - def Xangle(*args): return _Piavca_base.Quat_Xangle(*args)
249 - def Yangle(*args): return _Piavca_base.Quat_Yangle(*args)
250 - def Zangle(*args): return _Piavca_base.Quat_Zangle(*args)
252 - def projectToAxis(*args): return _Piavca_base.Quat_projectToAxis(*args)
253 - def pointAt(*args): return _Piavca_base.Quat_pointAt(*args)
254 - def __mul__(*args): return _Piavca_base.Quat___mul__(*args)
255 - def __imul__(*args): return _Piavca_base.Quat___imul__(*args)
256 - def __div__(*args): return _Piavca_base.Quat___div__(*args)
257 - def __idiv__(*args): return _Piavca_base.Quat___idiv__(*args)
258 - def __eq__(*args): return _Piavca_base.Quat___eq__(*args)
259 - def __ne__(*args): return _Piavca_base.Quat___ne__(*args)
260 - def Scale(*args): return _Piavca_base.Quat_Scale(*args)
261 - def inverse(*args): return _Piavca_base.Quat_inverse(*args)
262 - def invert(*args): return _Piavca_base.Quat_invert(*args)
263 - def normalise(*args): return _Piavca_base.Quat_normalise(*args)
266 __swig_getmethods__["spherical_distance"] = lambda x: _Piavca_base.Quat_spherical_distance
267 if _newclass:spherical_distance = staticmethod(_Piavca_base.Quat_spherical_distance)
268 - def logMap(*args): return _Piavca_base.Quat_logMap(*args)
269 __swig_getmethods__["expMap"] = lambda x: _Piavca_base.Quat_expMap
270 if _newclass:expMap = staticmethod(_Piavca_base.Quat_expMap)
271 - def __getitem__(*args): return _Piavca_base.Quat___getitem__(*args)
272 - def __setitem__(*args): return _Piavca_base.Quat___setitem__(*args)
273 - def __repr__(*args): return _Piavca_base.Quat___repr__(*args)
274 Quat_swigregister = _Piavca_base.Quat_swigregister
275 Quat_swigregister(Quat)
276 Quat_spherical_distance = _Piavca_base.Quat_spherical_distance
277 Quat_expMap = _Piavca_base.Quat_expMap
278
279 slerp = _Piavca_base.slerp
281 __swig_setmethods__ = {}
282 __setattr__ = lambda self, name, value: _swig_setattr(self, Bound, name, value)
283 __swig_getmethods__ = {}
284 __getattr__ = lambda self, name: _swig_getattr(self, Bound, name)
285 __repr__ = _swig_repr
286 __swig_setmethods__["min"] = _Piavca_base.Bound_min_set
287 __swig_getmethods__["min"] = _Piavca_base.Bound_min_get
288 if _newclass:min = _swig_property(_Piavca_base.Bound_min_get, _Piavca_base.Bound_min_set)
289 __swig_setmethods__["max"] = _Piavca_base.Bound_max_set
290 __swig_getmethods__["max"] = _Piavca_base.Bound_max_get
291 if _newclass:max = _swig_property(_Piavca_base.Bound_max_get, _Piavca_base.Bound_max_set)
293 this = _Piavca_base.new_Bound(*args)
294 try: self.this.append(this)
295 except: self.this = this
296 __swig_destroy__ = _Piavca_base.delete_Bound
297 __del__ = lambda self : None;
298 - def __add__(*args): return _Piavca_base.Bound___add__(*args)
299 - def __iadd__(*args): return _Piavca_base.Bound___iadd__(*args)
300 - def __eq__(*args): return _Piavca_base.Bound___eq__(*args)
301 - def __ne__(*args): return _Piavca_base.Bound___ne__(*args)
302 Bound_swigregister = _Piavca_base.Bound_swigregister
303 Bound_swigregister(Bound)
304
305 StringToWString = _Piavca_base.StringToWString
306 WStringToString = _Piavca_base.WStringToString
307 LOCAL_COORD = _Piavca_base.LOCAL_COORD
308 JOINTLOCAL_COORD = _Piavca_base.JOINTLOCAL_COORD
309 BASE_COORD = _Piavca_base.BASE_COORD
310 INCLUDINGBASE_COORD = _Piavca_base.INCLUDINGBASE_COORD
311 WORLD_COORD = _Piavca_base.WORLD_COORD
312 root_position_id = _Piavca_base.root_position_id
313 root_orientation_id = _Piavca_base.root_orientation_id
315 """
316 A callback that is called by the API every frame, the user writes code by creating a subclass of the callback.
317
318 The user can add data and implement the changeTime method (which is the one that is called everyframe). The callback system is currently under developement see also: TimeCallback.h
319 """
320 __swig_setmethods__ = {}
321 __setattr__ = lambda self, name, value: _swig_setattr(self, TimeCallback, name, value)
322 __swig_getmethods__ = {}
323 __getattr__ = lambda self, name: _swig_getattr(self, TimeCallback, name)
324 __repr__ = _swig_repr
326 """
327 Piavca::TimeCallback::TimeCallback(tstring _name)
328
329
330
331
332 """
333 if self.__class__ == TimeCallback:
334 args = (None,) + args
335 else:
336 args = (self,) + args
337 this = _Piavca_base.new_TimeCallback(*args)
338 try: self.this.append(this)
339 except: self.this = this
340 __swig_destroy__ = _Piavca_base.delete_TimeCallback
341 __del__ = lambda self : None;
343 """
344 tstring Piavca::TimeCallback::getName()
345
346
347
348
349 """
350 return _Piavca_base.TimeCallback_getName(*args)
351
353 """
354 virtual void Piavca::TimeCallback::init(Core *core)=0
355
356 This is a setup method for the callback.
357
358 It's called when the callback is registered
359 """
360 return _Piavca_base.TimeCallback_init(*args)
361
363 """
364 virtual void Piavca::TimeCallback::timeStep(Core *core, float time)=0
365
366 implement this to make the callback do things
367
368 It's called every frame with by the API
369 """
370 return _Piavca_base.TimeCallback_timeStep(*args)
371
373 self.this.disown()
374 _Piavca_base.disown_TimeCallback(self)
375 return weakref_proxy(self)
376 TimeCallback_swigregister = _Piavca_base.TimeCallback_swigregister
377 TimeCallback_swigregister(TimeCallback)
378 checkNaN = _Piavca_base.checkNaN
379
381 """
382 A callback that is called by the API every frame on an avatar.
383
384 It is very similar to the TimeCallback class but the changeTime method takes an avatar which can be updated. see also: TimeCallback.h
385 """
386 __swig_setmethods__ = {}
387 __setattr__ = lambda self, name, value: _swig_setattr(self, AvatarTimeCallback, name, value)
388 __swig_getmethods__ = {}
389 __getattr__ = lambda self, name: _swig_getattr(self, AvatarTimeCallback, name)
390 __repr__ = _swig_repr
392 """
393 Piavca::AvatarTimeCallback::AvatarTimeCallback(tstring _name)
394
395
396
397
398 """
399 if self.__class__ == AvatarTimeCallback:
400 args = (None,) + args
401 else:
402 args = (self,) + args
403 this = _Piavca_base.new_AvatarTimeCallback(*args)
404 try: self.this.append(this)
405 except: self.this = this
406 __swig_destroy__ = _Piavca_base.delete_AvatarTimeCallback
407 __del__ = lambda self : None;
409 """
410 tstring Piavca::AvatarTimeCallback::getName()
411
412
413
414
415 """
416 return _Piavca_base.AvatarTimeCallback_getName(*args)
417
419 """
420 virtual void Piavca::AvatarTimeCallback::init(Avatar *avatar)=0
421
422 This is a setup method for the callback.
423
424 It's called when the callback is registered
425 """
426 return _Piavca_base.AvatarTimeCallback_init(*args)
427
429 """
430 virtual void Piavca::AvatarTimeCallback::timeStep(Avatar *avatar, float time)=0
431
432 implement this to make the callback do things
433
434 It's called every frame with by the API which passes in the avatar to which the callback is attatched
435 """
436 return _Piavca_base.AvatarTimeCallback_timeStep(*args)
437
439 self.this.disown()
440 _Piavca_base.disown_AvatarTimeCallback(self)
441 return weakref_proxy(self)
442 AvatarTimeCallback_swigregister = _Piavca_base.AvatarTimeCallback_swigregister
443 AvatarTimeCallback_swigregister(AvatarTimeCallback)
444
445 NULL_TYPE = _Piavca_base.NULL_TYPE
446 FLOAT_TYPE = _Piavca_base.FLOAT_TYPE
447 VEC_TYPE = _Piavca_base.VEC_TYPE
448 QUAT_TYPE = _Piavca_base.QUAT_TYPE
449 TRANS_NONE = _Piavca_base.TRANS_NONE
450 TRANS_SWAP_XZ = _Piavca_base.TRANS_SWAP_XZ
451 TRANS_SWAP_XY = _Piavca_base.TRANS_SWAP_XY
452 TRANS_SWAP_YZ = _Piavca_base.TRANS_SWAP_YZ
453 TRANS_CYCLE_YZX = _Piavca_base.TRANS_CYCLE_YZX
454 TRANS_CYCLE_ZXY = _Piavca_base.TRANS_CYCLE_ZXY
455 TRANS_NEG_X = _Piavca_base.TRANS_NEG_X
456 TRANS_NEG_Y = _Piavca_base.TRANS_NEG_Y
457 TRANS_NEG_Z = _Piavca_base.TRANS_NEG_Z
458 TRANS_ARM_UP = _Piavca_base.TRANS_ARM_UP
459 TRANS_ARM_DOWN = _Piavca_base.TRANS_ARM_DOWN
460 TRANS_REVERSE_ORDER = _Piavca_base.TRANS_REVERSE_ORDER
461 TRANS_SKIP_FIRST_FRAME = _Piavca_base.TRANS_SKIP_FIRST_FRAME
462 TRANS_NO_ROOT_POS_CORRECTION = _Piavca_base.TRANS_NO_ROOT_POS_CORRECTION
464 """
465 An abstract interface to represent motion.
466
467 This is an abstract interface that represents all types of animation in a way that is independent of individual Avatars. It can be used to represent keyframe animation, motion combination, procedural animatio or real time animation streams. The key abstraction is that motion consists of a number of tracks, each normally corresponding to a joint of the avatar. The track is a continuous, time varying stream of data value (either of float, Vec or Quat type). The fundamental operation on a track is to query it for its value at a given time. Like joints tracks are represented by integer IDs, the IDs of a corresponding track and joint are the same so testing for equivelence is easy. Tracks are accessed by passing the appropriate ID to a method of the motion object. see also: Motion.h
468 """
469 __swig_setmethods__ = {}
470 __setattr__ = lambda self, name, value: _swig_setattr(self, Motion, name, value)
471 __swig_getmethods__ = {}
472 __getattr__ = lambda self, name: _swig_getattr(self, Motion, name)
473 __repr__ = _swig_repr
475 """
476 Piavca::Motion::Motion(const Motion &mot)
477
478
479
480
481 """
482 if self.__class__ == Motion:
483 args = (None,) + args
484 else:
485 args = (self,) + args
486 this = _Piavca_base.new_Motion(*args)
487 try: self.this.append(this)
488 except: self.this = this
489 __swig_destroy__ = _Piavca_base.delete_Motion
490 __del__ = lambda self : None;
492 """
493 virtual Motion* Piavca::Motion::clone()=0
494
495 creates a copy of the motion
496
497
498 """
499 return _Piavca_base.Motion_clone(*args)
500
501 - def getClassName(*args): return _Piavca_base.Motion_getClassName(*args)
502 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.Motion_castToThisType
503 if _newclass:castToThisType = staticmethod(_Piavca_base.Motion_castToThisType)
504 - def create(*args): return _Piavca_base.Motion_create(*args)
506 """
507 void Motion::printInfo()
508
509 prints out info about the motion heirarchy
510
511
512 """
513 return _Piavca_base.Motion_printInfo(*args)
514
515 - def getId(*args): return _Piavca_base.Motion_getId(*args)
516 - def __eq__(*args): return _Piavca_base.Motion___eq__(*args)
517 - def __ne__(*args): return _Piavca_base.Motion___ne__(*args)
519 """
520 virtual void Piavca::Motion::load(Avatar *av)
521
522 called when the motion is loaded into an avatar
523
524
525 """
526 return _Piavca_base.Motion_load(*args)
527
529 """
530 virtual void Piavca::Motion::unload()
531
532 called when the motion is unloaded from an avatar
533
534
535 """
536 return _Piavca_base.Motion_unload(*args)
537
539 """
540 virtual bool Piavca::Motion::loaded()
541
542 checks if the motion has been loaded into an avatar
543
544
545 """
546 return _Piavca_base.Motion_loaded(*args)
547
548 - def getAvatar(*args): return _Piavca_base.Motion_getAvatar(*args)
550 """
551 virtual void Piavca::Motion::setStartTime(float t)
552
553 sets the start time of the motion. Called when its loaded into an avatar.
554
555
556 """
557 return _Piavca_base.Motion_setStartTime(*args)
558
560 """
561 float Piavca::Motion::getStartTime()
562
563 return the start time of the motion
564
565
566 """
567 return _Piavca_base.Motion_getStartTime(*args)
568
570 """
571 float Piavca::Motion::getEndTime()
572
573 returns the end time of the motion
574
575
576 """
577 return _Piavca_base.Motion_getEndTime(*args)
578
579 - def finished(*args): return _Piavca_base.Motion_finished(*args)
581 """
582 virtual void Piavca::Motion::reset()
583
584 does any resetting needed
585
586
587 """
588 return _Piavca_base.Motion_reset(*args)
589
590 - def passEvent(*args): return _Piavca_base.Motion_passEvent(*args)
591 - def handleEvent(*args): return _Piavca_base.Motion_handleEvent(*args)
592 - def canHandleEvent(*args): return _Piavca_base.Motion_canHandleEvent(*args)
593 - def getEventNames(*args): return _Piavca_base.Motion_getEventNames(*args)
595 - def wasVisited(*args): return _Piavca_base.Motion_wasVisited(*args)
596 - def sendEvent(*args): return _Piavca_base.Motion_sendEvent(*args)
598 """
599 void Piavca::Motion::Reference()
600
601 registers an owner for a motion, the motion will not be deleted until disposed is called.
602
603 Internally this increments the reference count.
604 """
605 return _Piavca_base.Motion_Reference(*args)
606
608 """
609 void Motion::Dispose()
610
611 decrements the references count and deletes the motion if it reaches zero
612
613
614 """
615 return _Piavca_base.Motion_Dispose(*args)
616
618 """
619 void Piavca::Motion::makeTemp()
620
621 makes a motion temporary so that it is removed when all avatars have finished with it
622
623
624 """
625 return _Piavca_base.Motion_makeTemp(*args)
626
628 """
629 void Piavca::Motion::setName(tstring nm)
630
631 gives a name to the motion
632
633
634 """
635 return _Piavca_base.Motion_setName(*args)
636
638 """
639 tstring Piavca::Motion::getName()
640
641 returns the name of the motion
642
643
644 """
645 return _Piavca_base.Motion_getName(*args)
646
648 """
649 virtual Motion* Piavca::Motion::findSub(tstring nm)
650
651 finds the first submotion with a given name
652
653
654 """
655 return _Piavca_base.Motion_findSub(*args)
656
658 """
659 virtual Motion* Piavca::Motion::findSubByType(const type_info &ty)
660
661 finds the first submotion with a given type
662
663
664 """
665 return _Piavca_base.Motion_findSubByType(*args)
666
668 """
669 virtual float Piavca::Motion::getMotionLength() const =0
670
671 gets the time of the end of the motion
672
673 Though time is represented in floating point, keyframes can only be set as integers to avoid problems with rounding errors. The granularity is the conversion factor between the two.
674 """
675 return _Piavca_base.Motion_getMotionLength(*args)
676
678 """
679 virtual bool Piavca::Motion::isRandomAccess()
680
681 whether you can access a motions value at frames other than the current one
682
683
684 """
685 return _Piavca_base.Motion_isRandomAccess(*args)
686
688 """
689 int Piavca::Motion::begin() const
690
691 the ID of the first track that is present in the motion (the ordering is arbitrary)
692
693
694 """
695 return _Piavca_base.Motion_begin(*args)
696
698 """
699 int Motion::end() const
700
701 the last track + 1
702
703
704 """
705 return _Piavca_base.Motion_end(*args)
706
708 """
709 int Motion::next(int &trackId) const
710
711 given a track ID get the next valid ID
712
713
714 """
715 return _Piavca_base.Motion_next(*args)
716
718 """
719 virtual bool Piavca::Motion::isNull(int trackId) const =0
720
721 given a track ID tests whether it actually points to anything or if its null
722
723
724 """
725 return _Piavca_base.Motion_isNull(*args)
726
728 """
729 virtual trackType Piavca::Motion::getTrackType(int trackId) const =0
730
731 get the type of the track corresponding to an ID
732
733
734 """
735 return _Piavca_base.Motion_getTrackType(*args)
736
738 """
739 void Motion::pause()
740
741 pause the motion so that it can be restarted from the current point
742
743
744 """
745 return _Piavca_base.Motion_pause(*args)
746
748 """
749 void Motion::unpause()
750
751
752
753
754 """
755 return _Piavca_base.Motion_unpause(*args)
756
757 - def preFrame(*args): return _Piavca_base.Motion_preFrame(*args)
759 """
760 float Piavca::Motion::getFloatValueAtTime(int trackId, float time)
761
762 get the value of a track at a given time (only works for floats)
763
764
765 """
766 return _Piavca_base.Motion_getFloatValueAtTime(*args)
767
769 """
770 Vec Piavca::Motion::getVecValueAtTime(int trackId, float time)
771
772 get the value of a track at a given time (only works for Vecs)
773
774
775 """
776 return _Piavca_base.Motion_getVecValueAtTime(*args)
777
779 """
780 Quat Piavca::Motion::getQuatValueAtTime(int trackId, float time)
781
782 get the value of a track at a given time (only works for Quats)
783
784
785 """
786 return _Piavca_base.Motion_getQuatValueAtTime(*args)
787
789 """
790 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
791
792 internal version of getFloatValueAtTime, to be overridden
793
794
795 """
796 return _Piavca_base.Motion_getFloatValueAtTimeInternal(*args)
797
799 """
800 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
801
802 internal version of getVecValueAtTime, to be overridden
803
804
805 """
806 return _Piavca_base.Motion_getVecValueAtTimeInternal(*args)
807
809 """
810 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
811
812 internal version of getQuatValueAtTime, to be overridden
813
814
815 """
816 return _Piavca_base.Motion_getQuatValueAtTimeInternal(*args)
817
819 self.this.disown()
820 _Piavca_base.disown_Motion(self)
821 return weakref_proxy(self)
822 Motion_swigregister = _Piavca_base.Motion_swigregister
823 Motion_swigregister(Motion)
824 Motion_castToThisType = _Piavca_base.Motion_castToThisType
825
826 -class Core(_object):
827 """
828 The core object is the central controller of the Piavca system.
829
830 It maintains a list of avatars, and some motions. It has a list of global callbacks that are called every frame. It handles allocation of Joint IDs. It deals with initialisation and shut down and per frame events. It also manages creation of avatar and motions. There is only ever one core object (held as the core static member of the class). see also: PiavcaCore.h
831 """
832 __swig_setmethods__ = {}
833 __setattr__ = lambda self, name, value: _swig_setattr(self, Core, name, value)
834 __swig_getmethods__ = {}
835 __getattr__ = lambda self, name: _swig_getattr(self, Core, name)
836 - def __init__(self): raise AttributeError, "No constructor defined"
837 __repr__ = _swig_repr
838 __swig_setmethods__["dir"] = _Piavca_base.Core_dir_set
839 __swig_getmethods__["dir"] = _Piavca_base.Core_dir_get
840 if _newclass:dir = _swig_property(_Piavca_base.Core_dir_get, _Piavca_base.Core_dir_set)
841 __swig_destroy__ = _Piavca_base.delete_Core
842 __del__ = lambda self : None;
844 """
845 void Core::reset()
846
847
848
849
850 """
851 return _Piavca_base.Core_reset(*args)
852
853 __swig_getmethods__["init"] = lambda x: _Piavca_base.Core_init
854 if _newclass:init = staticmethod(_Piavca_base.Core_init)
855 __swig_getmethods__["setCore"] = lambda x: _Piavca_base.Core_setCore
856 if _newclass:setCore = staticmethod(_Piavca_base.Core_setCore)
858 """
859 static Core* Piavca::Core::getCore()
860
861 a static function to get the core instances (there is only one)
862
863
864 """
865 return _Piavca_base.Core_getCore(*args)
866
867 if _newclass:getCore = staticmethod(getCore)
868 __swig_getmethods__["getCore"] = lambda x: getCore
869 __swig_getmethods__["getCorePointerAsLong"] = lambda x: _Piavca_base.Core_getCorePointerAsLong
870 if _newclass:getCorePointerAsLong = staticmethod(_Piavca_base.Core_getCorePointerAsLong)
872 """
873 void Core::registerCallback(TimeCallback *cb)
874
875 registers a callback to be called every frame
876
877
878 """
879 return _Piavca_base.Core_registerCallback(*args)
880
882 """
883 void Core::timeStep(float time)
884
885
886
887 Performs all per frame actions Can be run in parallel with the renderer.
888 """
889 return _Piavca_base.Core_timeStep(*args)
890
892 """
893 void Core::prerender()
894
895 called before rendering (this cannot be called in parallel with the render)
896
897
898 """
899 return _Piavca_base.Core_prerender(*args)
900
902 """
903 void Core::render()
904
905 On certain platforms this needs to be called to render the avatars.
906
907
908 """
909 return _Piavca_base.Core_render(*args)
910
911 - def setHardware(*args): return _Piavca_base.Core_setHardware(*args)
912 - def getHardware(*args): return _Piavca_base.Core_getHardware(*args)
914 """
915 int Core::getJointId(tstring name)
916
917
918
919 methods dealing with joint ids get an id corresponding to a joint name
920 """
921 return _Piavca_base.Core_getJointId(*args)
922
924 """
925 int Piavca::Core::getMaxJointId()
926
927 gets the maximum joint id
928
929
930 """
931 return _Piavca_base.Core_getMaxJointId(*args)
932
934 """
935 void Core::addJointNameSet(StringVector names)
936
937 Adds in a set of joints all of which should have the same id.
938
939 i.e. all the names correspond to the same joint e.g. (left_foot, LFoot, LeftFoot, PiedGauche)
940 """
941 return _Piavca_base.Core_addJointNameSet(*args)
942
944 """
945 tstring Core::getJointName(int jointId)
946
947 returns a name corresponding to a track id (out of many possible)
948
949
950 """
951 return _Piavca_base.Core_getJointName(*args)
952
954 """
955 std::vector< std::pair< tstring, int > > Core::getJointNameAssociations()
956
957 get all the joint name associations
958
959
960 """
961 return _Piavca_base.Core_getJointNameAssociations(*args)
962
964 """
965 int Core::getExpressionId(tstring name)
966
967
968
969 methods dealing with expression ids get an id corresponding to an expression name
970 """
971 return _Piavca_base.Core_getExpressionId(*args)
972
974 """
975 int Piavca::Core::getMaxExpressionId()
976
977 gets the maximum joint id
978
979
980 """
981 return _Piavca_base.Core_getMaxExpressionId(*args)
982
984 """
985 void Core::addExpressionNameSet(StringVector names)
986
987 Adds in a set of joints all of which should have the same id.
988
989 i.e. all the names correspond to the same joint e.g. (left_foot, LFoot, LeftFoot, PiedGauche)
990 """
991 return _Piavca_base.Core_addExpressionNameSet(*args)
992
994 """
995 tstring Core::getExpressionName(int expressionId)
996
997 returns a name corresponding to a track id (out of many possible)
998
999
1000 """
1001 return _Piavca_base.Core_getExpressionName(*args)
1002
1004 """
1005 std::vector< std::pair< tstring, int > > Core::getExpressionNameAssociations()
1006
1007 get all the expression name associations
1008
1009
1010 """
1011 return _Piavca_base.Core_getExpressionNameAssociations(*args)
1012
1013 - def getTrackId(*args): return _Piavca_base.Core_getTrackId(*args)
1014 - def getMaxTrackId(*args): return _Piavca_base.Core_getMaxTrackId(*args)
1015 - def getMinTrackId(*args): return _Piavca_base.Core_getMinTrackId(*args)
1016 - def getTrackName(*args): return _Piavca_base.Core_getTrackName(*args)
1019 """
1020 void Core::loadMotion(tstring motionName, Motion *mot, bool temp=false, Motion *basePosture=NULL)
1021
1022 adds a motion to its list of motions
1023
1024
1025 """
1026 return _Piavca_base.Core_loadMotion(*args)
1027
1029 """
1030 void Core::renameMotion(tstring oldName, tstring newName)
1031
1032 changes the name of a motion
1033
1034
1035 """
1036 return _Piavca_base.Core_renameMotion(*args)
1037
1039 """
1040 void Core::unloadMotion(tstring name)
1041
1042 removes the motion from the core and deletes it (NB difference to disposeMotion)
1043
1044
1045 """
1046 return _Piavca_base.Core_unloadMotion(*args)
1047
1049 """
1050 PIAVCA_EXPORT std::vector< std::string > Core::getMotionNames(int number=0)
1051
1052 get motion names
1053
1054
1055 """
1056 return _Piavca_base.Core_getMotionNames(*args)
1057
1059 """
1060 int Piavca::Core::getNumberOfMotions()
1061
1062 get number of motions
1063
1064
1065 """
1066 return _Piavca_base.Core_getNumberOfMotions(*args)
1067
1069 """
1070 PIAVCA_EXPORT std::list< tstring > Core::getAllmotions()
1071
1072 get all motion names
1073
1074
1075 """
1076 return _Piavca_base.Core_getAllmotions(*args)
1077
1079 """
1080 Motion* Piavca::Core::getMotion(int i)
1081
1082 get a motion by its (arbitrary) index
1083
1084
1085 """
1086 return _Piavca_base.Core_getMotion(*args)
1087
1088 - def loadAvatar(*args): return _Piavca_base.Core_loadAvatar(*args)
1090 """
1091 std::vector< tstring > Core::getAvatarNames()
1092
1093
1094
1095
1096 """
1097 return _Piavca_base.Core_getAvatarNames(*args)
1098
1100 """
1101 int Piavca::Core::numAvatars()
1102
1103 get the number of avatars
1104
1105
1106 """
1107 return _Piavca_base.Core_numAvatars(*args)
1108
1110 """
1111 Avatar * Core::getAvatar(int i)
1112
1113 get the ith avatar in the list (used for interating over all avatars)
1114
1115
1116 """
1117 return _Piavca_base.Core_getAvatar(*args)
1118
1120 """
1121 void Core::renameAvatar(tstring oldName, tstring newName)
1122
1123 changes the name of an avatar
1124
1125
1126 """
1127 return _Piavca_base.Core_renameAvatar(*args)
1128
1130 """
1131 void Core::removeAvatar(Avatar *avatar)
1132
1133 removes and avatar
1134
1135
1136 """
1137 return _Piavca_base.Core_removeAvatar(*args)
1138
1140 """
1141 void Core::initAvatar(Avatar *avatar, tstring avatarId, bool bailOnMissedJoints=false, const Vec &Position=Vec(0.0, 0.0, 0.0), const Quat &Orientation=Quat(1.0, 0.0, 0.0, 0.0))
1142
1143 Initialises an avatar.
1144
1145 You pass in a pointer to the avatar and an id with which to initialise it. It creates an implementation object which will actually be a platform dependant sub type of AvatarImp. It then sets some stuff up and stores a pointer to the avatar.
1146 """
1147 return _Piavca_base.Core_initAvatar(*args)
1148
1150 """
1151 int Piavca::Core::numObjects()
1152
1153 get the number of avatars
1154
1155
1156 """
1157 return _Piavca_base.Core_numObjects(*args)
1158
1160 """
1161 Object * Core::getObject(int i)
1162
1163 get the ith avatar in the list (used for interating over all avatars)
1164
1165
1166 """
1167 return _Piavca_base.Core_getObject(*args)
1168
1170 """
1171 void Core::renameObject(tstring oldName, tstring newName)
1172
1173 changes the name of an avatar
1174
1175
1176 """
1177 return _Piavca_base.Core_renameObject(*args)
1178
1180 """
1181 void Core::removeObject(Object *object)
1182
1183 removes and avatar
1184
1185
1186 """
1187 return _Piavca_base.Core_removeObject(*args)
1188
1190 """
1191 void Core::initObject(Object *object, tstring objectId, const Vec &Position=Vec(0.0, 0.0, 0.0), const Quat &Orientation=Quat(1.0, 0.0, 0.0, 0.0))
1192
1193 Initialises an object.
1194
1195 You pass in a pointer to the object and an id with which to initialise it. It creates an implementation object which will actually be a platform dependant sub type of ObjectImp. It then sets some stuff up and stores a pointer to the object.
1196 """
1197 return _Piavca_base.Core_initObject(*args)
1198
1200 """
1201 void Core::initMotion(TrackMotion *mot, tstring filename=_PSTR(""), bool facial=false, int flags=0, Motion *basePosture=NULL)
1202
1203 Initialises a TrackMotion object.
1204
1205 You pass in a pointer to the TrackMotion and a filename with which to initialise it. It creates an implementation object which will actually be a platform dependant sub type of MotionImp.
1206 """
1207 return _Piavca_base.Core_initMotion(*args)
1208
1210 """
1211 void Piavca::Core::setDir(tstring _dir)
1212
1213 set the search directory
1214
1215
1216 """
1217 return _Piavca_base.Core_setDir(*args)
1218
1220 """
1221 float Piavca::Core::getTime()
1222
1223 get the current time in seconds
1224
1225
1226 """
1227 return _Piavca_base.Core_getTime(*args)
1228
1230 """
1231 virtual float Piavca::Core::getSystemTime()=0
1232
1233 get the current time in seconds
1234
1235
1236 """
1237 return _Piavca_base.Core_getSystemTime(*args)
1238
1240 """
1241 void Piavca::Core::setAutoTimeOff()
1242
1243 turns off the automatic updating of the current time from the system clock
1244
1245
1246 """
1247 return _Piavca_base.Core_setAutoTimeOff(*args)
1248
1250 """
1251 void Piavca::Core::setAutoTimeOn()
1252
1253 turns on the automatic updating of the current time from the system clock
1254
1255
1256 """
1257 return _Piavca_base.Core_setAutoTimeOn(*args)
1258
1260 """
1261 void Piavca::Core::setCurrentTime(float t)
1262
1263 sets the current time (if its not linked to the system clock
1264
1265
1266 """
1267 return _Piavca_base.Core_setCurrentTime(*args)
1268
1270 """
1271 void Core::addError(tstring details)
1272
1273
1274
1275
1276 """
1277 return _Piavca_base.Core_addError(*args)
1278
1280 """
1281 tostringstream& Piavca::Core::error()
1282
1283
1284
1285
1286 """
1287 return _Piavca_base.Core_error(*args)
1288
1290 """
1291 void Core::clearErrors()
1292
1293
1294
1295
1296 """
1297 return _Piavca_base.Core_clearErrors(*args)
1298
1300 """
1301 tstring Piavca::Core::getErrors()
1302
1303
1304
1305
1306 """
1307 return _Piavca_base.Core_getErrors(*args)
1308
1310 """
1311 bool Piavca::Core::errorsPresent()
1312
1313
1314
1315
1316 """
1317 return _Piavca_base.Core_errorsPresent(*args)
1318
1320 """
1321 void Core::addWarning(tstring details)
1322
1323
1324
1325
1326 """
1327 return _Piavca_base.Core_addWarning(*args)
1328
1330 """
1331 tostringstream& Piavca::Core::Warning()
1332
1333
1334
1335
1336 """
1337 return _Piavca_base.Core_Warning(*args)
1338
1340 """
1341 void Core::clearWarnings()
1342
1343
1344
1345
1346 """
1347 return _Piavca_base.Core_clearWarnings(*args)
1348
1350 """
1351 tstring Piavca::Core::getWarnings()
1352
1353
1354
1355
1356 """
1357 return _Piavca_base.Core_getWarnings(*args)
1358
1360 """
1361 bool Piavca::Core::warningsPresent()
1362
1363
1364
1365
1366 """
1367 return _Piavca_base.Core_warningsPresent(*args)
1368
1370 """
1371 bool Piavca::Core::exceptionsOn()
1372
1373
1374
1375
1376 """
1377 return _Piavca_base.Core_exceptionsOn(*args)
1378
1380 """
1381 void Piavca::Core::setExceptionsOn()
1382
1383
1384
1385
1386 """
1387 return _Piavca_base.Core_setExceptionsOn(*args)
1388
1390 """
1391 void Piavca::Core::setExceptionsOff()
1392
1393
1394
1395
1396 """
1397 return _Piavca_base.Core_setExceptionsOff(*args)
1398
1400 """
1401 std::ostream& Piavca::Core::log()
1402
1403
1404
1405
1406 """
1407 return _Piavca_base.Core_log(*args)
1408
1410 """
1411 int Piavca::Core::addProfilePoint(tstring name)
1412
1413
1414
1415 creates a new profile point for logging profile data. Returns and id which can be used to access the profile point. You would normally create the point id as a static variable within the function you are profiling.
1416 """
1417 return _Piavca_base.Core_addProfilePoint(*args)
1418
1420 """
1421 void Piavca::Core::profilePointStart(int i)
1422
1423 marks the start of a profile point
1424
1425
1426 """
1427 return _Piavca_base.Core_profilePointStart(*args)
1428
1430 """
1431 void Piavca::Core::profilePointEnd(int i)
1432
1433 marks the end of the profile point
1434
1435
1436 """
1437 return _Piavca_base.Core_profilePointEnd(*args)
1438
1440 """
1441 void Core::printProfileData()
1442
1443 prints out the profiling data that has been collected.
1444
1445
1446 """
1447 return _Piavca_base.Core_printProfileData(*args)
1448
1449 - def output(*args): return _Piavca_base.Core_output(*args)
1450 - def message(*args): return _Piavca_base.Core_message(*args)
1451 - def getMessages(*args): return _Piavca_base.Core_getMessages(*args)
1452 Core_swigregister = _Piavca_base.Core_swigregister
1453 Core_swigregister(Core)
1454 Core_init = _Piavca_base.Core_init
1455 Core_setCore = _Piavca_base.Core_setCore
1456
1458 """
1459 static Core* Piavca::Core::getCore()
1460
1461 a static function to get the core instances (there is only one)
1462
1463
1464 """
1465 return _Piavca_base.Core_getCore(*args)
1466 Core_getCorePointerAsLong = _Piavca_base.Core_getCorePointerAsLong
1467 cvar = _Piavca_base.cvar
1468 Core.nullId = _Piavca_base.cvar.Core_nullId
1469
1471 __swig_setmethods__ = {}
1472 for _s in [Motion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
1473 __setattr__ = lambda self, name, value: _swig_setattr(self, KeyframeMotion, name, value)
1474 __swig_getmethods__ = {}
1475 for _s in [Motion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
1476 __getattr__ = lambda self, name: _swig_getattr(self, KeyframeMotion, name)
1477 __repr__ = _swig_repr
1479 if self.__class__ == KeyframeMotion:
1480 args = (None,) + args
1481 else:
1482 args = (self,) + args
1483 this = _Piavca_base.new_KeyframeMotion(*args)
1484 try: self.this.append(this)
1485 except: self.this = this
1486 __swig_destroy__ = _Piavca_base.delete_KeyframeMotion
1487 __del__ = lambda self : None;
1489 """
1490 virtual Motion* Piavca::Motion::clone()=0
1491
1492 creates a copy of the motion
1493
1494
1495 """
1496 return _Piavca_base.KeyframeMotion_clone(*args)
1497
1498 - def getClassName(*args): return _Piavca_base.KeyframeMotion_getClassName(*args)
1499 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.KeyframeMotion_castToThisType
1500 if _newclass:castToThisType = staticmethod(_Piavca_base.KeyframeMotion_castToThisType)
1502 """
1503 virtual float Piavca::Motion::getMotionLength() const =0
1504
1505 gets the time of the end of the motion
1506
1507 Though time is represented in floating point, keyframes can only be set as integers to avoid problems with rounding errors. The granularity is the conversion factor between the two.
1508 """
1509 return _Piavca_base.KeyframeMotion_getMotionLength(*args)
1510
1511 - def setFacial(*args): return _Piavca_base.KeyframeMotion_setFacial(*args)
1513 """
1514 virtual bool Piavca::Motion::isRandomAccess()
1515
1516 whether you can access a motions value at frames other than the current one
1517
1518
1519 """
1520 return _Piavca_base.KeyframeMotion_isRandomAccess(*args)
1521
1523 """
1524 virtual bool Piavca::Motion::isNull(int trackId) const =0
1525
1526 given a track ID tests whether it actually points to anything or if its null
1527
1528
1529 """
1530 return _Piavca_base.KeyframeMotion_isNull(*args)
1531
1533 """
1534 virtual trackType Piavca::Motion::getTrackType(int trackId) const =0
1535
1536 get the type of the track corresponding to an ID
1537
1538
1539 """
1540 return _Piavca_base.KeyframeMotion_getTrackType(*args)
1541
1542 - def addFloatTrack(*args): return _Piavca_base.KeyframeMotion_addFloatTrack(*args)
1543 - def addVecTrack(*args): return _Piavca_base.KeyframeMotion_addVecTrack(*args)
1544 - def addQuatTrack(*args): return _Piavca_base.KeyframeMotion_addQuatTrack(*args)
1545 - def setFloatKeyframe(*args): return _Piavca_base.KeyframeMotion_setFloatKeyframe(*args)
1546 - def setVecKeyframe(*args): return _Piavca_base.KeyframeMotion_setVecKeyframe(*args)
1547 - def setQuatKeyframe(*args): return _Piavca_base.KeyframeMotion_setQuatKeyframe(*args)
1548 - def getNumKeyframes(*args): return _Piavca_base.KeyframeMotion_getNumKeyframes(*args)
1549 - def getKeyframeTime(*args): return _Piavca_base.KeyframeMotion_getKeyframeTime(*args)
1551 """
1552 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
1553
1554 internal version of getFloatValueAtTime, to be overridden
1555
1556
1557 """
1558 return _Piavca_base.KeyframeMotion_getFloatValueAtTimeInternal(*args)
1559
1561 """
1562 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
1563
1564 internal version of getVecValueAtTime, to be overridden
1565
1566
1567 """
1568 return _Piavca_base.KeyframeMotion_getVecValueAtTimeInternal(*args)
1569
1571 """
1572 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
1573
1574 internal version of getQuatValueAtTime, to be overridden
1575
1576
1577 """
1578 return _Piavca_base.KeyframeMotion_getQuatValueAtTimeInternal(*args)
1579
1580 - def deleteAllTracks(*args): return _Piavca_base.KeyframeMotion_deleteAllTracks(*args)
1581 - def clearTrack(*args): return _Piavca_base.KeyframeMotion_clearTrack(*args)
1582 - def clearAllTracks(*args): return _Piavca_base.KeyframeMotion_clearAllTracks(*args)
1584 self.this.disown()
1585 _Piavca_base.disown_KeyframeMotion(self)
1586 return weakref_proxy(self)
1587 KeyframeMotion_swigregister = _Piavca_base.KeyframeMotion_swigregister
1588 KeyframeMotion_swigregister(KeyframeMotion)
1589 KeyframeMotion_castToThisType = _Piavca_base.KeyframeMotion_castToThisType
1590
1591
1593 """
1594 TrackMotion * Piavca::copyMotionPosture(Motion *mot, float time)
1595
1596 creates a Track Motion that is a copy of the given motion at a given time
1597
1598
1599 """
1600 return _Piavca_base.copyMotionPosture(*args)
1602 """
1603 The actual avatar class.
1604
1605 This class is the main component of the Piavca API and represents a character for skeletal animation. It has fairly basic simple functionality, just altering root position and orientation, loading and playing motion and directly altering joint orientations It is an interfaces class that forwards all its method calls to an implementation class which is an platform specific class that does all the work. The class is structured as a bridge pattern from Design Patterns. An interface class contains a pointer to an implementation object and forwards all method calls to it. The implementation object is in fact of a platform specific sub-type of the implementation class. The joints themselves are not exposed to the client and are accessed via integer IDs. These IDs are unique for a given joint across all avatars and motions. any actions on joints area achieved by passing the ID to an appropriate method see also: Avatar.h
1606 """
1607 __swig_setmethods__ = {}
1608 __setattr__ = lambda self, name, value: _swig_setattr(self, Avatar, name, value)
1609 __swig_getmethods__ = {}
1610 __getattr__ = lambda self, name: _swig_getattr(self, Avatar, name)
1611 __repr__ = _swig_repr
1613 """
1614 Avatar::Avatar(tstring avatarId, bool bailOnMissedJoints=false, const Vec &Position=Vec(0.0, 0.0, 0.0), const Quat &Orientation=Quat(1.0, 0.0, 0.0, 0.0), const Vec &forwardDir=Vec(0.0, 0.0, 1.0))
1615
1616 create an avatar
1617
1618 The avatar needs to be initialised with an implementation. The type of the implementation depends on the platform and so it cannot be created directly in platform independant code. To get around this it is created by a static factory method in the which itself uses the Piavca::Core class and its platform dependent implementation to create the implementation of the avatar. The constructor needs an identifier string that it uses to find platform specific data needed to create the avatar, for example the mesh file. The user can also pass in a position and orientation for the avatar. If bail on missed joints is true it will fail to create the avatar if not all the needed joints are present in the model and will result in an invalid avatar (this can be tested with the isValid method).
1619 """
1620 this = _Piavca_base.new_Avatar(*args)
1621 try: self.this.append(this)
1622 except: self.this = this
1624 """
1625 bool Piavca::Avatar::isValid()
1626
1627 set the current piavca core object
1628
1629
1630 """
1631 return _Piavca_base.Avatar_isValid(*args)
1632
1634 """
1635 void Avatar::activate()
1636
1637 turn on updates on the avatar
1638
1639
1640 """
1641 return _Piavca_base.Avatar_activate(*args)
1642
1644 """
1645 void Avatar::deactivate()
1646
1647 turn off updates on the avatar
1648
1649
1650 """
1651 return _Piavca_base.Avatar_deactivate(*args)
1652
1654 """
1655 tstring Piavca::Avatar::getName()
1656
1657 get the name of the avatar
1658
1659
1660 """
1661 return _Piavca_base.Avatar_getName(*args)
1662
1664 """
1665 tstring Piavca::Avatar::setName(tstring newName)
1666
1667 set the name of the avatar
1668
1669
1670 """
1671 return _Piavca_base.Avatar_setName(*args)
1672
1673 - def setScale(*args): return _Piavca_base.Avatar_setScale(*args)
1674 - def getScale(*args): return _Piavca_base.Avatar_getScale(*args)
1675 - def hideBodyPart(*args): return _Piavca_base.Avatar_hideBodyPart(*args)
1676 - def showBodyPart(*args): return _Piavca_base.Avatar_showBodyPart(*args)
1678 """
1679 void Piavca::Avatar::clearFacialExpressionWeights()
1680
1681 set all expression weights to zero
1682
1683
1684 """
1685 return _Piavca_base.Avatar_clearFacialExpressionWeights(*args)
1686
1688 """
1689 int Piavca::Avatar::beginExpression() const
1690
1691 the ID of the first joint that is present in the avatar (the ordering is arbitrary)
1692
1693
1694 """
1695 return _Piavca_base.Avatar_beginExpression(*args)
1696
1698 """
1699 int Avatar::endExpression() const
1700
1701 the last joint + 1
1702
1703
1704 """
1705 return _Piavca_base.Avatar_endExpression(*args)
1706
1708 """
1709 int Avatar::nextExpression(int &expressionId)
1710
1711 given a joint ID this returns the next joint ID that is present in the avatar
1712
1713
1714 """
1715 return _Piavca_base.Avatar_nextExpression(*args)
1716
1718 """
1719 bool Piavca::Avatar::isExpressionNull(int expressionId) const
1720
1721 whether the joint is present in the avatar
1722
1723
1724 """
1725 return _Piavca_base.Avatar_isExpressionNull(*args)
1726
1728 """
1729 void Piavca::Avatar::setRootPosition(const Vec &Position)
1730
1731
1732
1733 get or set the root position and orientation of the avatar
1734 """
1735 return _Piavca_base.Avatar_setRootPosition(*args)
1736
1738 """
1739 Vec Piavca::Avatar::getRootPosition()
1740
1741
1742
1743
1744 """
1745 return _Piavca_base.Avatar_getRootPosition(*args)
1746
1748 """
1749 void Piavca::Avatar::setRootOrientation(const Quat &Orientation)
1750
1751
1752
1753
1754 """
1755 return _Piavca_base.Avatar_setRootOrientation(*args)
1756
1758 """
1759 void Piavca::Avatar::setRootAngle(float angle)
1760
1761 set the root orientation from an angle in radians (assumed to be about the verticle)
1762
1763
1764 """
1765 return _Piavca_base.Avatar_setRootAngle(*args)
1766
1768 """
1769 void Piavca::Avatar::setRootAngleDeg(float angle)
1770
1771 set the root orientation from an angle in degrees (assumed to be about the verticle)
1772
1773
1774 """
1775 return _Piavca_base.Avatar_setRootAngleDeg(*args)
1776
1778 """
1779 Quat Piavca::Avatar::getRootOrientation()
1780
1781
1782
1783
1784 """
1785 return _Piavca_base.Avatar_getRootOrientation(*args)
1786
1788 """
1789 bool Piavca::Avatar::createJoint(tstring jointName)
1790
1791 creates a new joint
1792
1793 It will only succeed if there is a piece of geometry corresponding to the name if not it returns false.
1794 """
1795 return _Piavca_base.Avatar_createJoint(*args)
1796
1798 """
1799 int Piavca::Avatar::begin() const
1800
1801 the ID of the first joint that is present in the avatar (the ordering is arbitrary)
1802
1803
1804 """
1805 return _Piavca_base.Avatar_begin(*args)
1806
1808 """
1809 int Avatar::end() const
1810
1811 the last joint + 1
1812
1813
1814 """
1815 return _Piavca_base.Avatar_end(*args)
1816
1818 """
1819 int Avatar::next(int &jointId)
1820
1821 given a joint ID this returns the next joint ID that is present in the avatar
1822
1823
1824 """
1825 return _Piavca_base.Avatar_next(*args)
1826
1828 """
1829 int Piavca::Avatar::getParent(int jointId) const
1830
1831 returns the ID of the parent of the joint in the joint heirarchy (or a negative value if it doesn't exist
1832
1833
1834 """
1835 return _Piavca_base.Avatar_getParent(*args)
1836
1838 """
1839 const tstring Piavca::Avatar::getJointName(int jointId)
1840
1841 get the name of the joint corresponding to an ID
1842
1843
1844 """
1845 return _Piavca_base.Avatar_getJointName(*args)
1846
1848 """
1849 bool Piavca::Avatar::isNull(int jointId) const
1850
1851 whether the joint is present in the avatar
1852
1853
1854 """
1855 return _Piavca_base.Avatar_isNull(*args)
1856
1858 """
1859 bool Piavca::Avatar::hasChanged(int jointId)
1860
1861 check whether the joint has been changed by user input
1862
1863
1864 """
1865 return _Piavca_base.Avatar_hasChanged(*args)
1866
1868 """
1869 void Piavca::Avatar::clearChange(int jointId)
1870
1871 clears the changed flag for the joint
1872
1873
1874 """
1875 return _Piavca_base.Avatar_clearChange(*args)
1876
1877 - def setJointPosition(*args): return _Piavca_base.Avatar_setJointPosition(*args)
1879 """
1880 void Piavca::Avatar::scaleRoot(Vec scale)
1881
1882 scales the root by a non-uniform scale vector
1883
1884
1885 """
1886 return _Piavca_base.Avatar_scaleRoot(*args)
1887
1889 """
1890 void Piavca::Avatar::scaleJoint(int jointId, Vec scale)
1891
1892 scales a joint by a non-uniform scale vector
1893
1894
1895 """
1896 return _Piavca_base.Avatar_scaleJoint(*args)
1897
1898 - def getBoundBox(*args): return _Piavca_base.Avatar_getBoundBox(*args)
1899 - def getBaseBoundBox(*args): return _Piavca_base.Avatar_getBaseBoundBox(*args)
1901 """
1902 void Avatar::timeStep(float time)
1903
1904 set the current time
1905
1906 This is used for animation, it sets the time within the current piece of motion and puts the avatar in the correct position for that motion at that time
1907 """
1908 return _Piavca_base.Avatar_timeStep(*args)
1909
1911 """
1912 void Avatar::loadMotion(Motion *motion)
1913
1914 load motion as a motion object
1915
1916 The start time allows the client to specify a time in world time for the motion to start running
1917 """
1918 return _Piavca_base.Avatar_loadMotion(*args)
1919
1921 """
1922 void Avatar::unloadMotion()
1923
1924
1925
1926
1927 """
1928 return _Piavca_base.Avatar_unloadMotion(*args)
1929
1931 """
1932 const Motion* Piavca::Avatar::getMotion() const
1933
1934 get a const pointer to the motion so it can be seen by the client
1935
1936
1937 """
1938 return _Piavca_base.Avatar_getMotion(*args)
1939
1941 """
1942 void Avatar::playMotion(Motion *m)
1943
1944
1945
1946
1947 """
1948 return _Piavca_base.Avatar_playMotion(*args)
1949
1951 """
1952 void Avatar::playMotion(Motion *m)
1953
1954
1955
1956
1957 """
1958 return _Piavca_base.Avatar_playMotionDirect(*args)
1959
1961 """
1962 void Piavca::Avatar::stopMotion()
1963
1964 stops the motion playing
1965
1966
1967 """
1968 return _Piavca_base.Avatar_stopMotion(*args)
1969
1971 """
1972 void Piavca::Avatar::restartMotion()
1973
1974 restarts the motion without changing the start time
1975
1976
1977 """
1978 return _Piavca_base.Avatar_restartMotion(*args)
1979
1981 """
1982 void Avatar::setMotionStartTime(float startTime)
1983
1984 changes the start time of the motion
1985
1986
1987 """
1988 return _Piavca_base.Avatar_setMotionStartTime(*args)
1989
1991 """
1992 float Avatar::getMotionStartTime()
1993
1994 get the time when the current motion starts
1995
1996
1997 """
1998 return _Piavca_base.Avatar_getMotionStartTime(*args)
1999
2001 """
2002 float Avatar::getMotionEndTime()
2003
2004 get the time when the current motion should end
2005
2006
2007 """
2008 return _Piavca_base.Avatar_getMotionEndTime(*args)
2009
2011 """
2012 void Avatar::showMotionAtTime(float time)
2013
2014 displays the motion on the avatar at time
2015
2016
2017 """
2018 return _Piavca_base.Avatar_showMotionAtTime(*args)
2019
2021 """
2022 void Avatar::loadScaleMotion(Motion *motion)
2023
2024 load a scale motion as a motion object
2025
2026 The start time allows the client to specify a time in world time for the motion to start running
2027 """
2028 return _Piavca_base.Avatar_loadScaleMotion(*args)
2029
2031 """
2032 void Avatar::unloadScaleMotion()
2033
2034
2035
2036
2037 """
2038 return _Piavca_base.Avatar_unloadScaleMotion(*args)
2039
2041 """
2042 const Motion* Piavca::Avatar::getScaleMotion() const
2043
2044 get a const pointer to the motion so it can be seen by the client
2045
2046
2047 """
2048 return _Piavca_base.Avatar_getScaleMotion(*args)
2049
2051 """
2052 void Avatar::playScaleMotion(Motion *m)
2053
2054 starts playing the motion at the current time
2055
2056
2057 """
2058 return _Piavca_base.Avatar_playScaleMotion(*args)
2059
2061 """
2062 void Piavca::Avatar::stopScaleMotion()
2063
2064 stops the motion playing
2065
2066
2067 """
2068 return _Piavca_base.Avatar_stopScaleMotion(*args)
2069
2071 """
2072 void Piavca::Avatar::restartScaleMotion()
2073
2074 restarts the motion without changing the start time
2075
2076
2077 """
2078 return _Piavca_base.Avatar_restartScaleMotion(*args)
2079
2081 """
2082 void Avatar::setScaleMotionStartTime(float startTime)
2083
2084 changes the start time of the motion
2085
2086
2087 """
2088 return _Piavca_base.Avatar_setScaleMotionStartTime(*args)
2089
2091 """
2092 float Avatar::getScaleMotionStartTime()
2093
2094 get the time when the current motion starts
2095
2096
2097 """
2098 return _Piavca_base.Avatar_getScaleMotionStartTime(*args)
2099
2101 """
2102 float Avatar::getScaleMotionEndTime()
2103
2104 get the time when the current motion should end
2105
2106
2107 """
2108 return _Piavca_base.Avatar_getScaleMotionEndTime(*args)
2109
2111 """
2112 void Avatar::showScaleMotionAtTime(float time)
2113
2114 displays the motion on the avatar at time
2115
2116
2117 """
2118 return _Piavca_base.Avatar_showScaleMotionAtTime(*args)
2119
2121 """
2122 void Avatar::registerCallback(AvatarTimeCallback *cb)
2123
2124 registers a callback so that it is called on the avatar every frame
2125
2126
2127 """
2128 return _Piavca_base.Avatar_registerCallback(*args)
2129
2131 """
2132 void Avatar::removeCallback(tstring cbName)
2133
2134 deletes a callback
2135
2136
2137 """
2138 return _Piavca_base.Avatar_removeCallback(*args)
2139
2141 """
2142 int Avatar::getNumCallbacks()
2143
2144 gets the number of registered callbacks (for iterating through them)
2145
2146
2147 """
2148 return _Piavca_base.Avatar_getNumCallbacks(*args)
2149
2151 """
2152 AvatarTimeCallback * Avatar::getCallback(int i)
2153
2154 get a callback based on its index (the indeces are arbitrary this is just useful for finding a callback)
2155
2156
2157 """
2158 return _Piavca_base.Avatar_getCallback(*args)
2159
2160 - def event(*args): return _Piavca_base.Avatar_event(*args)
2162 """
2163 bool Piavca::Avatar::setFacialExpressionWeight(int id, float weight, float timeInterval=0.5)
2164
2165 set the weight of a facial expression (used in the blend)
2166
2167
2168 """
2169 return _Piavca_base.Avatar_setFacialExpressionWeight(*args)
2170
2172 """
2173 float Piavca::Avatar::getFacialExpressionWeight(int id)
2174
2175 get the weight of an expression
2176
2177
2178 """
2179 return _Piavca_base.Avatar_getFacialExpressionWeight(*args)
2180
2182 """
2183 void Avatar::setJointOrientation(std::vector< std::pair< int, Quat > > jointOrientation, jointCoord worldCoord=JOINTLOCAL_COORD)
2184
2185 set all the joint orientations from a vector of joint IDs and values
2186
2187 This can be done in various coordinate systems, jointlocal is the coordante space of the joint (default) local is the space of the avatar root world is the world coordinates using the second two is likely to be much less efficient
2188 """
2189 return _Piavca_base.Avatar_setJointOrientation(*args)
2190
2192 """
2193 Quat Piavca::Avatar::getJointOrientation(int jointId, jointCoord worldCoord=JOINTLOCAL_COORD)
2194
2195 get the orientation of a joint
2196
2197 The joint is specified via an ID. This can be done in various coordinate systems, jointlocal is the coordante space of the joint (default) local is the space of the avatar root world is the world coordinates using the second two is likely to be much less efficient
2198 """
2199 return _Piavca_base.Avatar_getJointOrientation(*args)
2200
2202 """
2203 Vec Piavca::Avatar::getJointBasePosition(int jointId, jointCoord worldCoord=LOCAL_COORD)
2204
2205 get the current position of the start point of the joint
2206
2207 calculated from the root position and joint angles by forward kinematics This can be done in various coordinate systems, jointlocal is the coordante space of the joint local is the space of the avatar root (default) world is the world coordinates
2208 """
2209 return _Piavca_base.Avatar_getJointBasePosition(*args)
2210
2211 - def play_motion(*args): return _Piavca_base.Avatar_play_motion(*args)
2213 - def interrupt_motion(*args): return _Piavca_base.Avatar_interrupt_motion(*args)
2214 - def stop_motion(*args): return _Piavca_base.Avatar_stop_motion(*args)
2217 Avatar_swigregister = _Piavca_base.Avatar_swigregister
2218 Avatar_swigregister(Avatar)
2219
2221 __swig_setmethods__ = {}
2222 __setattr__ = lambda self, name, value: _swig_setattr(self, queueElement, name, value)
2223 __swig_getmethods__ = {}
2224 __getattr__ = lambda self, name: _swig_getattr(self, queueElement, name)
2225 __repr__ = _swig_repr
2226 __swig_setmethods__["mot"] = _Piavca_base.queueElement_mot_set
2227 __swig_getmethods__["mot"] = _Piavca_base.queueElement_mot_get
2228 if _newclass:mot = _swig_property(_Piavca_base.queueElement_mot_get, _Piavca_base.queueElement_mot_set)
2229 __swig_setmethods__["name"] = _Piavca_base.queueElement_name_set
2230 __swig_getmethods__["name"] = _Piavca_base.queueElement_name_get
2231 if _newclass:name = _swig_property(_Piavca_base.queueElement_name_get, _Piavca_base.queueElement_name_set)
2232 __swig_setmethods__["atTime"] = _Piavca_base.queueElement_atTime_set
2233 __swig_getmethods__["atTime"] = _Piavca_base.queueElement_atTime_get
2234 if _newclass:atTime = _swig_property(_Piavca_base.queueElement_atTime_get, _Piavca_base.queueElement_atTime_set)
2235 __swig_setmethods__["background"] = _Piavca_base.queueElement_background_set
2236 __swig_getmethods__["background"] = _Piavca_base.queueElement_background_get
2237 if _newclass:background = _swig_property(_Piavca_base.queueElement_background_get, _Piavca_base.queueElement_background_set)
2239 this = _Piavca_base.new_queueElement(*args)
2240 try: self.this.append(this)
2241 except: self.this = this
2242 __swig_destroy__ = _Piavca_base.delete_queueElement
2243 __del__ = lambda self : None;
2244 queueElement_swigregister = _Piavca_base.queueElement_swigregister
2245 queueElement_swigregister(queueElement)
2246
2248 """
2249 A Queue for managing motions.
2250
2251 You can put motions on the queue and they will be played in sequence each waiting for the previous to finish. You can also add background motions that continuing playing at the same time as the motions on the queue. see also: AvatarMotionQueue.h
2252 """
2253 __swig_setmethods__ = {}
2254 for _s in [AvatarTimeCallback]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
2255 __setattr__ = lambda self, name, value: _swig_setattr(self, AvatarMotionQueue, name, value)
2256 __swig_getmethods__ = {}
2257 for _s in [AvatarTimeCallback]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
2258 __getattr__ = lambda self, name: _swig_getattr(self, AvatarMotionQueue, name)
2259 __repr__ = _swig_repr
2261 """
2262 Piavca::AvatarMotionQueue::AvatarMotionQueue(const AvatarMotionQueue &amq)
2263
2264
2265
2266
2267 """
2268 this = _Piavca_base.new_AvatarMotionQueue(*args)
2269 try: self.this.append(this)
2270 except: self.this = this
2271 __swig_destroy__ = _Piavca_base.delete_AvatarMotionQueue
2272 __del__ = lambda self : None;
2273 __swig_getmethods__["getQueue"] = lambda x: _Piavca_base.AvatarMotionQueue_getQueue
2274 if _newclass:getQueue = staticmethod(_Piavca_base.AvatarMotionQueue_getQueue)
2275 __swig_getmethods__["hasQueue"] = lambda x: _Piavca_base.AvatarMotionQueue_hasQueue
2276 if _newclass:hasQueue = staticmethod(_Piavca_base.AvatarMotionQueue_hasQueue)
2278 """
2279 void AvatarMotionQueue::init(Piavca::Avatar *avatar)
2280
2281 This is a setup method for the callback.
2282
2283 It's called when the callback is registered
2284 """
2285 return _Piavca_base.AvatarMotionQueue_init(*args)
2286
2288 """
2289 void AvatarMotionQueue::timeStep(Piavca::Avatar *avatar, float time)
2290
2291 implement this to make the callback do things
2292
2293 It's called every frame with by the API which passes in the avatar to which the callback is attatched
2294 """
2295 return _Piavca_base.AvatarMotionQueue_timeStep(*args)
2296
2298 """
2299 float Piavca::AvatarMotionQueue::getCurrentMotionStart()
2300
2301 gets the start time of the current motion
2302
2303
2304 """
2305 return _Piavca_base.AvatarMotionQueue_getCurrentMotionStart(*args)
2306
2308 """
2309 void Piavca::AvatarMotionQueue::reblend()
2310
2311
2312
2313
2314 """
2315 return _Piavca_base.AvatarMotionQueue_reblend(*args)
2316
2318 """
2319 void Piavca::AvatarMotionQueue::setBlendInterval(float t)
2320
2321 sets how long it takes to blend between subsequent motions.
2322
2323
2324 """
2325 return _Piavca_base.AvatarMotionQueue_setBlendInterval(*args)
2326
2328 """
2329 void AvatarMotionQueue::enqueueMotion(tstring name, Piavca::Motion *motion, float atTime=0.0)
2330
2331 adds a motion to the queue
2332
2333 You have to pass in a name for the motion and optionally a minimum time for it to start.
2334 """
2335 return _Piavca_base.AvatarMotionQueue_enqueueMotion(*args)
2336
2338 """
2339 void AvatarMotionQueue::enqueueRandomMotions(int num=0)
2340
2341 enqueue a number of randomly chosen motions
2342
2343
2344 """
2345 return _Piavca_base.AvatarMotionQueue_enqueueRandomMotions(*args)
2346
2348 """
2349 bool AvatarMotionQueue::queueTopIsBackground()
2350
2351 tests whether the first motion on the queue is a background motion
2352
2353
2354 """
2355 return _Piavca_base.AvatarMotionQueue_queueTopIsBackground(*args)
2356
2358 """
2359 float AvatarMotionQueue::queueTopTime()
2360
2361 gets the minimum start time of the first motion on the queue
2362
2363
2364 """
2365 return _Piavca_base.AvatarMotionQueue_queueTopTime(*args)
2366
2368 """
2369 Motion * AvatarMotionQueue::dequeueMotion()
2370
2371 pops a motion off the queue
2372
2373
2374 """
2375 return _Piavca_base.AvatarMotionQueue_dequeueMotion(*args)
2376
2378 """
2379 int Piavca::AvatarMotionQueue::getQueueSize()
2380
2381 returns the number of motions on the queue
2382
2383
2384 """
2385 return _Piavca_base.AvatarMotionQueue_getQueueSize(*args)
2386
2388 """
2389 void Piavca::AvatarMotionQueue::updateDelay(float delay)
2390
2391 change the delay
2392
2393
2394 """
2395 return _Piavca_base.AvatarMotionQueue_updateDelay(*args)
2396
2398 """
2399 void AvatarMotionQueue::clearQueue()
2400
2401 empties the queue
2402
2403
2404 """
2405 return _Piavca_base.AvatarMotionQueue_clearQueue(*args)
2406
2408 """
2409 void AvatarMotionQueue::removeMotion(tstring name)
2410
2411 removes a named forground motion
2412
2413
2414 """
2415 return _Piavca_base.AvatarMotionQueue_removeMotion(*args)
2416
2418 """
2419 void Piavca::AvatarMotionQueue::pauseMotion(tstring name)
2420
2421 pauses a named forground motion
2422
2423
2424 """
2425 return _Piavca_base.AvatarMotionQueue_pauseMotion(*args)
2426
2428 """
2429 void Piavca::AvatarMotionQueue::unpauseMotion(tstring name)
2430
2431 unpauses a named forground motion
2432
2433
2434 """
2435 return _Piavca_base.AvatarMotionQueue_unpauseMotion(*args)
2436
2438 """
2439 void AvatarMotionQueue::clearAllBackgroundMotions()
2440
2441 removes all background motions from the queue
2442
2443
2444 """
2445 return _Piavca_base.AvatarMotionQueue_clearAllBackgroundMotions(*args)
2446
2448 """
2449 void AvatarMotionQueue::clearFinishedBackgroundMotions()
2450
2451 removes any background motions that have stopped playing
2452
2453
2454 """
2455 return _Piavca_base.AvatarMotionQueue_clearFinishedBackgroundMotions(*args)
2456
2458 """
2459 void AvatarMotionQueue::removeBackgroundMotion(tstring name)
2460
2461 removes a named background motion
2462
2463
2464 """
2465 return _Piavca_base.AvatarMotionQueue_removeBackgroundMotion(*args)
2466
2468 """
2469 void AvatarMotionQueue::removeBackgroundMotionByType(const type_info &ty)
2470
2471 removes a background motion with a given type
2472
2473
2474 """
2475 return _Piavca_base.AvatarMotionQueue_removeBackgroundMotionByType(*args)
2476
2478 """
2479 void AvatarMotionQueue::pauseBackgroundMotion(tstring name)
2480
2481 pauses a named background motion
2482
2483
2484 """
2485 return _Piavca_base.AvatarMotionQueue_pauseBackgroundMotion(*args)
2486
2488 """
2489 void AvatarMotionQueue::unpauseBackgroundMotion(tstring name)
2490
2491 unpauses a named background motion
2492
2493
2494 """
2495 return _Piavca_base.AvatarMotionQueue_unpauseBackgroundMotion(*args)
2496
2498 """
2499 void Piavca::AvatarMotionQueue::interrupt()
2500
2501 interrupts the queue
2502
2503 so the next motion is played immediately, without waiting for the current one stop
2504 """
2505 return _Piavca_base.AvatarMotionQueue_interrupt(*args)
2506
2507 - def repositionRelative(*args): return _Piavca_base.AvatarMotionQueue_repositionRelative(*args)
2508 - def repositionAbsolute(*args): return _Piavca_base.AvatarMotionQueue_repositionAbsolute(*args)
2510 """
2511 virtual Piavca::Motion* Piavca::AvatarMotionQueue::getMotion()
2512
2513 return the resulting motion
2514
2515
2516 """
2517 return _Piavca_base.AvatarMotionQueue_getMotion(*args)
2518
2520 """
2521 Motion * AvatarMotionQueue::blendMotion(Motion *m, Avatar *av, float scaleFactor)
2522
2523
2524
2525
2526 """
2527 return _Piavca_base.AvatarMotionQueue_blendMotion(*args)
2528
2530 """
2531 void AvatarMotionQueue::addBackgroundMotion(tstring name, Piavca::Motion *motion, float atTime=0.0)
2532
2533 adds a new background motion to the queue
2534
2535 A background motion is played concurrently with any motions on the queue. You have to pass in a name and optionally minimum time at which it should start.
2536 """
2537 return _Piavca_base.AvatarMotionQueue_addBackgroundMotion(*args)
2538
2539 AvatarMotionQueue_swigregister = _Piavca_base.AvatarMotionQueue_swigregister
2540 AvatarMotionQueue_swigregister(AvatarMotionQueue)
2541 AvatarMotionQueue_getQueue = _Piavca_base.AvatarMotionQueue_getQueue
2542 AvatarMotionQueue_hasQueue = _Piavca_base.AvatarMotionQueue_hasQueue
2543
2545 """
2546 A class for representing inanimate objects in PIAVCA.
2547
2548 This works much like an avatar, except its only got a root and not joints/facial exprssions. see also: Object.h
2549 """
2550 __swig_setmethods__ = {}
2551 __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
2552 __swig_getmethods__ = {}
2553 __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
2554 __repr__ = _swig_repr
2556 """
2557 Piavca::Object::Object(tstring objectId, const Vec &Position=Vec(0.0, 0.0, 0.0), const Quat &Orientation=Quat(1.0, 0.0, 0.0, 0.0))
2558
2559 create an object
2560
2561 The object needs to be initialised with an implementation. The type of the implementation depends on the platform and so it cannot be created directly in platform independant code. To get around this it is created by a static factory method in the which itself uses the Piavca::Core class and its platform dependent implementation to create the implementation of the avatar. The constructor needs an identifier string that it uses to find platform specific data needed to create the avatar, for example the mesh file. The user can also pass in a position and orientation for the object.
2562 """
2563 this = _Piavca_base.new_Object(*args)
2564 try: self.this.append(this)
2565 except: self.this = this
2567 """
2568 tstring Piavca::Object::getName()
2569
2570 get the name of the avatar
2571
2572
2573 """
2574 return _Piavca_base.Object_getName(*args)
2575
2577 """
2578 tstring Piavca::Object::setName(tstring newName)
2579
2580 set the name of the avatar
2581
2582
2583 """
2584 return _Piavca_base.Object_setName(*args)
2585
2587 """
2588 void Piavca::Object::setPosition(const Vec &Position)
2589
2590
2591
2592 get or set the root position and orientation of the avatar
2593 """
2594 return _Piavca_base.Object_setPosition(*args)
2595
2597 """
2598 Vec Piavca::Object::getPosition()
2599
2600
2601
2602
2603 """
2604 return _Piavca_base.Object_getPosition(*args)
2605
2607 """
2608 void Piavca::Object::setOrientation(const Quat &Orientation)
2609
2610
2611
2612
2613 """
2614 return _Piavca_base.Object_setOrientation(*args)
2615
2617 """
2618 void Piavca::Object::setAngle(float angle)
2619
2620 set the orientation from an angle in radians (assumed to be about the verticle)
2621
2622
2623 """
2624 return _Piavca_base.Object_setAngle(*args)
2625
2627 """
2628 void Piavca::Object::setAngleDeg(float angle)
2629
2630 set the orientation from an angle in degrees (assumed to be about the verticle)
2631
2632
2633 """
2634 return _Piavca_base.Object_setAngleDeg(*args)
2635
2637 """
2638 Quat Piavca::Object::getOrientation()
2639
2640
2641
2642
2643 """
2644 return _Piavca_base.Object_getOrientation(*args)
2645
2647 """
2648 void Piavca::Object::scale(Vec scale)
2649
2650 scales the root by a non-uniform scale vector
2651
2652
2653 """
2654 return _Piavca_base.Object_scale(*args)
2655
2656 Object_swigregister = _Piavca_base.Object_swigregister
2657 Object_swigregister(Object)
2658
2659
2661 """
2662 float Piavca::degToRad(float angle)
2663
2664 convert and angle in degrees to radians
2665
2666
2667 """
2668 return _Piavca_base.degToRad(*args)
2669
2671 """
2672 float Piavca::radToDeg(float angle)
2673
2674 convert and angle in radians to degrees
2675
2676
2677 """
2678 return _Piavca_base.radToDeg(*args)
2680 __swig_setmethods__ = {}
2681 for _s in [KeyframeMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
2682 __setattr__ = lambda self, name, value: _swig_setattr(self, CurrentValueMotion, name, value)
2683 __swig_getmethods__ = {}
2684 for _s in [KeyframeMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
2685 __getattr__ = lambda self, name: _swig_getattr(self, CurrentValueMotion, name)
2686 __repr__ = _swig_repr
2688 this = _Piavca_base.new_CurrentValueMotion(*args)
2689 try: self.this.append(this)
2690 except: self.this = this
2692 """
2693 virtual Motion* Piavca::Motion::clone()=0
2694
2695 creates a copy of the motion
2696
2697
2698 """
2699 return _Piavca_base.CurrentValueMotion_clone(*args)
2700
2701 - def getClassName(*args): return _Piavca_base.CurrentValueMotion_getClassName(*args)
2702 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.CurrentValueMotion_castToThisType
2703 if _newclass:castToThisType = staticmethod(_Piavca_base.CurrentValueMotion_castToThisType)
2704 - def setFloatValue(*args): return _Piavca_base.CurrentValueMotion_setFloatValue(*args)
2705 - def setVecValue(*args): return _Piavca_base.CurrentValueMotion_setVecValue(*args)
2706 - def setQuatValue(*args): return _Piavca_base.CurrentValueMotion_setQuatValue(*args)
2707 __swig_destroy__ = _Piavca_base.delete_CurrentValueMotion
2708 __del__ = lambda self : None;
2709 CurrentValueMotion_swigregister = _Piavca_base.CurrentValueMotion_swigregister
2710 CurrentValueMotion_swigregister(CurrentValueMotion)
2711 Pi = cvar.Pi
2712 CurrentValueMotion_castToThisType = _Piavca_base.CurrentValueMotion_castToThisType
2713
2715 """
2716 A motion class whose output is some transformation of another motion.
2717
2718 This class is an abstract base class that just provides some common features between motion filters. To actaully do anything you have to override the get[Float/Quat/Vec]ValueAtTime methods to perform whatever opertation you want on the other motion. see also: MotionFilter.h
2719 """
2720 __swig_setmethods__ = {}
2721 for _s in [Motion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
2722 __setattr__ = lambda self, name, value: _swig_setattr(self, MotionFilter, name, value)
2723 __swig_getmethods__ = {}
2724 for _s in [Motion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
2725 __getattr__ = lambda self, name: _swig_getattr(self, MotionFilter, name)
2726 __repr__ = _swig_repr
2728 """
2729 Piavca::MotionFilter::MotionFilter(const MotionFilter &mf)
2730
2731
2732
2733
2734 """
2735 if self.__class__ == MotionFilter:
2736 args = (None,) + args
2737 else:
2738 args = (self,) + args
2739 this = _Piavca_base.new_MotionFilter(*args)
2740 try: self.this.append(this)
2741 except: self.this = this
2742 __swig_destroy__ = _Piavca_base.delete_MotionFilter
2743 __del__ = lambda self : None;
2745 """
2746 virtual Motion* Piavca::Motion::clone()=0
2747
2748 creates a copy of the motion
2749
2750
2751 """
2752 return _Piavca_base.MotionFilter_clone(*args)
2753
2754 - def getClassName(*args): return _Piavca_base.MotionFilter_getClassName(*args)
2755 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MotionFilter_castToThisType
2756 if _newclass:castToThisType = staticmethod(_Piavca_base.MotionFilter_castToThisType)
2758 """
2759 void Piavca::MotionFilter::printInfo()
2760
2761 prints out info about the motion heirarchy
2762
2763
2764 """
2765 return _Piavca_base.MotionFilter_printInfo(*args)
2766
2768 """
2769 virtual Motion* Piavca::MotionFilter::findSub(tstring nm)
2770
2771 finds the first submotion with a given name
2772
2773
2774 """
2775 return _Piavca_base.MotionFilter_findSub(*args)
2776
2778 """
2779 virtual Motion* Piavca::MotionFilter::findSubByType(const type_info &ty)
2780
2781 finds the first submotion with a given type
2782
2783
2784 """
2785 return _Piavca_base.MotionFilter_findSubByType(*args)
2786
2788 """
2789 virtual void Piavca::MotionFilter::load(Avatar *av)
2790
2791 called when the motion is loaded into an avatar
2792
2793
2794 """
2795 return _Piavca_base.MotionFilter_load(*args)
2796
2798 """
2799 virtual void Piavca::MotionFilter::unload()
2800
2801 called when the motion is unloaded from an avatar
2802
2803
2804 """
2805 return _Piavca_base.MotionFilter_unload(*args)
2806
2808 """
2809 virtual bool Piavca::MotionFilter::loaded()
2810
2811 checks if the motion has been loaded into an avatar
2812
2813
2814 """
2815 return _Piavca_base.MotionFilter_loaded(*args)
2816
2817 - def preFrame(*args): return _Piavca_base.MotionFilter_preFrame(*args)
2818 - def getAvatar(*args): return _Piavca_base.MotionFilter_getAvatar(*args)
2820 """
2821 virtual void Piavca::MotionFilter::setStartTime(float time)
2822
2823 sets the start time of the motion. Called when its loaded into an avatar.
2824
2825
2826 """
2827 return _Piavca_base.MotionFilter_setStartTime(*args)
2828
2830 """
2831 void Piavca::MotionFilter::reset()
2832
2833 does any resetting needed
2834
2835
2836 """
2837 return _Piavca_base.MotionFilter_reset(*args)
2838
2839 - def handleEvent(*args): return _Piavca_base.MotionFilter_handleEvent(*args)
2840 - def canHandleEvent(*args): return _Piavca_base.MotionFilter_canHandleEvent(*args)
2843 """
2844 void Piavca::MotionFilter::setMotion(Motion *mot)
2845
2846
2847
2848
2849 """
2850 return _Piavca_base.MotionFilter_setMotion(*args)
2851
2852 - def getMotion(*args): return _Piavca_base.MotionFilter_getMotion(*args)
2854 """
2855 float Piavca::MotionFilter::getMotionLength() const
2856
2857 gets the length of the motion in seconds
2858
2859
2860 """
2861 return _Piavca_base.MotionFilter_getMotionLength(*args)
2862
2864 """
2865 virtual bool Piavca::MotionFilter::isRandomAccess()
2866
2867 whether you can access a motions value at frames other than the current one
2868
2869
2870 """
2871 return _Piavca_base.MotionFilter_isRandomAccess(*args)
2872
2874 """
2875 virtual bool Piavca::MotionFilter::isNull(int trackId) const
2876
2877 given an iterator tests whether it actually points to anything or if its null
2878
2879
2880 """
2881 return _Piavca_base.MotionFilter_isNull(*args)
2882
2884 """
2885 trackType Piavca::MotionFilter::getTrackType(int trackId) const
2886
2887 get the type of the track corresponding to an iterator
2888
2889
2890 """
2891 return _Piavca_base.MotionFilter_getTrackType(*args)
2892
2894 """
2895 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
2896
2897 internal version of getFloatValueAtTime, to be overridden
2898
2899
2900 """
2901 return _Piavca_base.MotionFilter_getFloatValueAtTimeInternal(*args)
2902
2904 """
2905 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
2906
2907 internal version of getVecValueAtTime, to be overridden
2908
2909
2910 """
2911 return _Piavca_base.MotionFilter_getVecValueAtTimeInternal(*args)
2912
2914 """
2915 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
2916
2917 internal version of getQuatValueAtTime, to be overridden
2918
2919
2920 """
2921 return _Piavca_base.MotionFilter_getQuatValueAtTimeInternal(*args)
2922
2924 self.this.disown()
2925 _Piavca_base.disown_MotionFilter(self)
2926 return weakref_proxy(self)
2927 MotionFilter_swigregister = _Piavca_base.MotionFilter_swigregister
2928 MotionFilter_swigregister(MotionFilter)
2929 MotionFilter_castToThisType = _Piavca_base.MotionFilter_castToThisType
2930
2932 """
2933 A motion manipulator that combine two different motion.
2934
2935 This class is an abstract base class that just provides some common features between motion filters. To actaully do anything you have to override the get[Float/Quat/Vec]ValueAtTime methods to perform whatever opertation you want on the two motion. see also: TwoMotionCombiner.h
2936 """
2937 __swig_setmethods__ = {}
2938 for _s in [Motion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
2939 __setattr__ = lambda self, name, value: _swig_setattr(self, TwoMotionCombiner, name, value)
2940 __swig_getmethods__ = {}
2941 for _s in [Motion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
2942 __getattr__ = lambda self, name: _swig_getattr(self, TwoMotionCombiner, name)
2943 __repr__ = _swig_repr
2945 """
2946 TwoMotionCombiner::TwoMotionCombiner(const TwoMotionCombiner &tmc)
2947
2948
2949
2950
2951 """
2952 if self.__class__ == TwoMotionCombiner:
2953 args = (None,) + args
2954 else:
2955 args = (self,) + args
2956 this = _Piavca_base.new_TwoMotionCombiner(*args)
2957 try: self.this.append(this)
2958 except: self.this = this
2959 __swig_destroy__ = _Piavca_base.delete_TwoMotionCombiner
2960 __del__ = lambda self : None;
2962 """
2963 virtual Motion* Piavca::Motion::clone()=0
2964
2965 creates a copy of the motion
2966
2967
2968 """
2969 return _Piavca_base.TwoMotionCombiner_clone(*args)
2970
2971 - def getClassName(*args): return _Piavca_base.TwoMotionCombiner_getClassName(*args)
2972 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.TwoMotionCombiner_castToThisType
2973 if _newclass:castToThisType = staticmethod(_Piavca_base.TwoMotionCombiner_castToThisType)
2975 """
2976 void TwoMotionCombiner::printInfo()
2977
2978 prints out info about the motion heirarchy
2979
2980
2981 """
2982 return _Piavca_base.TwoMotionCombiner_printInfo(*args)
2983
2985 """
2986 Motion * TwoMotionCombiner::findSub(tstring nm)
2987
2988 finds the first submotion with a given name
2989
2990
2991 """
2992 return _Piavca_base.TwoMotionCombiner_findSub(*args)
2993
2995 """
2996 Motion * TwoMotionCombiner::findSubByType(const type_info &ty)
2997
2998 finds the first submotion with a given type
2999
3000
3001 """
3002 return _Piavca_base.TwoMotionCombiner_findSubByType(*args)
3003
3005 """
3006 void TwoMotionCombiner::load(Avatar *av)
3007
3008 called when the motion is loaded into an avatar
3009
3010
3011 """
3012 return _Piavca_base.TwoMotionCombiner_load(*args)
3013
3015 """
3016 void TwoMotionCombiner::unload()
3017
3018 called when the motion is unloaded from an avatar
3019
3020
3021 """
3022 return _Piavca_base.TwoMotionCombiner_unload(*args)
3023
3025 """
3026 bool TwoMotionCombiner::loaded()
3027
3028 checks if the motion has been loaded into an avatar
3029
3030
3031 """
3032 return _Piavca_base.TwoMotionCombiner_loaded(*args)
3033
3034 - def getAvatar(*args): return _Piavca_base.TwoMotionCombiner_getAvatar(*args)
3036 """
3037 void TwoMotionCombiner::setStartTime(float time)
3038
3039 sets the start time of the motion. Called when its loaded into an avatar.
3040
3041
3042 """
3043 return _Piavca_base.TwoMotionCombiner_setStartTime(*args)
3044
3046 """
3047 void TwoMotionCombiner::reset()
3048
3049 does any resetting needed
3050
3051
3052 """
3053 return _Piavca_base.TwoMotionCombiner_reset(*args)
3054
3055 - def handleEvent(*args): return _Piavca_base.TwoMotionCombiner_handleEvent(*args)
3056 - def canHandleEvent(*args): return _Piavca_base.TwoMotionCombiner_canHandleEvent(*args)
3057 - def cleanRecursionState(*args): return _Piavca_base.TwoMotionCombiner_cleanRecursionState(*args)
3059 """
3060 float TwoMotionCombiner::getMotionLength() const
3061
3062 gets the length of the combined motion (by default the length of the longer of the two)
3063
3064
3065 """
3066 return _Piavca_base.TwoMotionCombiner_getMotionLength(*args)
3067
3069 """
3070 bool TwoMotionCombiner::isRandomAccess()
3071
3072 whether you can access a motions value at frames other than the current one
3073
3074
3075 """
3076 return _Piavca_base.TwoMotionCombiner_isRandomAccess(*args)
3077
3078 - def preFrame(*args): return _Piavca_base.TwoMotionCombiner_preFrame(*args)
3080 """
3081 bool TwoMotionCombiner::isNull(int trackId) const
3082
3083 given a track ID tests whether it actually points to anything or if its null
3084
3085 is null if the track is null in both motions.
3086 """
3087 return _Piavca_base.TwoMotionCombiner_isNull(*args)
3088
3090 """
3091 trackType TwoMotionCombiner::getTrackType(int trackId) const
3092
3093 get the type of the track corresponding to an iterator
3094
3095
3096 """
3097 return _Piavca_base.TwoMotionCombiner_getTrackType(*args)
3098
3100 """
3101 void TwoMotionCombiner::setMotion1(Motion *mot)
3102
3103
3104
3105
3106 """
3107 return _Piavca_base.TwoMotionCombiner_setMotion1(*args)
3108
3110 """
3111 void TwoMotionCombiner::setMotion2(Motion *mot)
3112
3113
3114
3115
3116 """
3117 return _Piavca_base.TwoMotionCombiner_setMotion2(*args)
3118
3120 """
3121 Motion* Piavca::TwoMotionCombiner::getMotion1()
3122
3123
3124
3125
3126 """
3127 return _Piavca_base.TwoMotionCombiner_getMotion1(*args)
3128
3130 """
3131 Motion* Piavca::TwoMotionCombiner::getMotion2()
3132
3133
3134
3135
3136 """
3137 return _Piavca_base.TwoMotionCombiner_getMotion2(*args)
3138
3140 - def getCombinedVecValue(*args): return _Piavca_base.TwoMotionCombiner_getCombinedVecValue(*args)
3141 - def getCombinedQuatValue(*args): return _Piavca_base.TwoMotionCombiner_getCombinedQuatValue(*args)
3143 """
3144 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
3145
3146 internal version of getFloatValueAtTime, to be overridden
3147
3148
3149 """
3150 return _Piavca_base.TwoMotionCombiner_getFloatValueAtTimeInternal(*args)
3151
3153 """
3154 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
3155
3156 internal version of getVecValueAtTime, to be overridden
3157
3158
3159 """
3160 return _Piavca_base.TwoMotionCombiner_getVecValueAtTimeInternal(*args)
3161
3163 """
3164 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
3165
3166 internal version of getQuatValueAtTime, to be overridden
3167
3168
3169 """
3170 return _Piavca_base.TwoMotionCombiner_getQuatValueAtTimeInternal(*args)
3171
3173 self.this.disown()
3174 _Piavca_base.disown_TwoMotionCombiner(self)
3175 return weakref_proxy(self)
3176 TwoMotionCombiner_swigregister = _Piavca_base.TwoMotionCombiner_swigregister
3177 TwoMotionCombiner_swigregister(TwoMotionCombiner)
3178 TwoMotionCombiner_castToThisType = _Piavca_base.TwoMotionCombiner_castToThisType
3179
3181 __swig_setmethods__ = {}
3182 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3183 __setattr__ = lambda self, name, value: _swig_setattr(self, MultiMotionCombiner, name, value)
3184 __swig_getmethods__ = {}
3185 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3186 __getattr__ = lambda self, name: _swig_getattr(self, MultiMotionCombiner, name)
3187 __repr__ = _swig_repr
3189 if self.__class__ == MultiMotionCombiner:
3190 args = (None,) + args
3191 else:
3192 args = (self,) + args
3193 this = _Piavca_base.new_MultiMotionCombiner(*args)
3194 try: self.this.append(this)
3195 except: self.this = this
3196 __swig_destroy__ = _Piavca_base.delete_MultiMotionCombiner
3197 __del__ = lambda self : None;
3199 """
3200 virtual Motion* Piavca::Motion::clone()=0
3201
3202 creates a copy of the motion
3203
3204
3205 """
3206 return _Piavca_base.MultiMotionCombiner_clone(*args)
3207
3208 - def getClassName(*args): return _Piavca_base.MultiMotionCombiner_getClassName(*args)
3209 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MultiMotionCombiner_castToThisType
3210 if _newclass:castToThisType = staticmethod(_Piavca_base.MultiMotionCombiner_castToThisType)
3212 """
3213 void Piavca::MotionFilter::printInfo()
3214
3215 prints out info about the motion heirarchy
3216
3217
3218 """
3219 return _Piavca_base.MultiMotionCombiner_printInfo(*args)
3220
3221 - def addMotion(*args): return _Piavca_base.MultiMotionCombiner_addMotion(*args)
3222 - def getMotionIndex(*args): return _Piavca_base.MultiMotionCombiner_getMotionIndex(*args)
3223 - def getNumMotions(*args): return _Piavca_base.MultiMotionCombiner_getNumMotions(*args)
3224 - def getMotionByIndex(*args): return _Piavca_base.MultiMotionCombiner_getMotionByIndex(*args)
3225 - def getMotion(*args): return _Piavca_base.MultiMotionCombiner_getMotion(*args)
3226 - def removeMotionByIndex(*args): return _Piavca_base.MultiMotionCombiner_removeMotionByIndex(*args)
3227 - def clear(*args): return _Piavca_base.MultiMotionCombiner_clear(*args)
3229 """
3230 virtual Motion* Piavca::MotionFilter::findSub(tstring nm)
3231
3232 finds the first submotion with a given name
3233
3234
3235 """
3236 return _Piavca_base.MultiMotionCombiner_findSub(*args)
3237
3239 """
3240 virtual Motion* Piavca::MotionFilter::findSubByType(const type_info &ty)
3241
3242 finds the first submotion with a given type
3243
3244
3245 """
3246 return _Piavca_base.MultiMotionCombiner_findSubByType(*args)
3247
3249 """
3250 virtual void Piavca::MotionFilter::load(Avatar *av)
3251
3252 called when the motion is loaded into an avatar
3253
3254
3255 """
3256 return _Piavca_base.MultiMotionCombiner_load(*args)
3257
3259 """
3260 virtual void Piavca::MotionFilter::unload()
3261
3262 called when the motion is unloaded from an avatar
3263
3264
3265 """
3266 return _Piavca_base.MultiMotionCombiner_unload(*args)
3267
3269 """
3270 virtual bool Piavca::MotionFilter::loaded()
3271
3272 checks if the motion has been loaded into an avatar
3273
3274
3275 """
3276 return _Piavca_base.MultiMotionCombiner_loaded(*args)
3277
3278 - def getAvatar(*args): return _Piavca_base.MultiMotionCombiner_getAvatar(*args)
3279 - def preFrame(*args): return _Piavca_base.MultiMotionCombiner_preFrame(*args)
3281 """
3282 virtual void Piavca::MotionFilter::setStartTime(float time)
3283
3284 sets the start time of the motion. Called when its loaded into an avatar.
3285
3286
3287 """
3288 return _Piavca_base.MultiMotionCombiner_setStartTime(*args)
3289
3291 """
3292 void Piavca::MotionFilter::reset()
3293
3294 does any resetting needed
3295
3296
3297 """
3298 return _Piavca_base.MultiMotionCombiner_reset(*args)
3299
3300 - def handleEvent(*args): return _Piavca_base.MultiMotionCombiner_handleEvent(*args)
3301 - def canHandleEvent(*args): return _Piavca_base.MultiMotionCombiner_canHandleEvent(*args)
3302 - def cleanRecursionState(*args): return _Piavca_base.MultiMotionCombiner_cleanRecursionState(*args)
3304 """
3305 float Piavca::MotionFilter::getMotionLength() const
3306
3307 gets the length of the motion in seconds
3308
3309
3310 """
3311 return _Piavca_base.MultiMotionCombiner_getMotionLength(*args)
3312
3314 """
3315 virtual bool Piavca::MotionFilter::isNull(int trackId) const
3316
3317 given an iterator tests whether it actually points to anything or if its null
3318
3319
3320 """
3321 return _Piavca_base.MultiMotionCombiner_isNull(*args)
3322
3324 """
3325 trackType Piavca::MotionFilter::getTrackType(int trackId) const
3326
3327 get the type of the track corresponding to an iterator
3328
3329
3330 """
3331 return _Piavca_base.MultiMotionCombiner_getTrackType(*args)
3332
3334 self.this.disown()
3335 _Piavca_base.disown_MultiMotionCombiner(self)
3336 return weakref_proxy(self)
3337 MultiMotionCombiner_swigregister = _Piavca_base.MultiMotionCombiner_swigregister
3338 MultiMotionCombiner_swigregister(MultiMotionCombiner)
3339 MultiMotionCombiner_castToThisType = _Piavca_base.MultiMotionCombiner_castToThisType
3340
3363 """
3364 void MotionMask::setMask(int track, bool val=true)
3365
3366 sets whether a given track should be played
3367
3368
3369 """
3370 return _Piavca_base.MotionMask_setMask(*args)
3371
3372 - def setAllMask(*args): return _Piavca_base.MotionMask_setAllMask(*args)
3374 """
3375 bool MotionMask::getMask(int track) const
3376
3377 gets the mask value for a track
3378
3379
3380 """
3381 return _Piavca_base.MotionMask_getMask(*args)
3382
3383 - def clearMask(*args): return _Piavca_base.MotionMask_clearMask(*args)
3384 - def __repr__(*args): return _Piavca_base.MotionMask___repr__(*args)
3385 __swig_destroy__ = _Piavca_base.delete_MotionMask
3386 __del__ = lambda self : None;
3387 MotionMask_swigregister = _Piavca_base.MotionMask_swigregister
3388 MotionMask_swigregister(MotionMask)
3389
3391 """
3392 plays different motions on different joints.
3393
3394 It uses a mask to tell which motion to play on which joint. see also: MaskedMotion.h
3395 """
3396 __swig_setmethods__ = {}
3397 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3398 __setattr__ = lambda self, name, value: _swig_setattr(self, MaskedMotion, name, value)
3399 __swig_getmethods__ = {}
3400 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3401 __getattr__ = lambda self, name: _swig_getattr(self, MaskedMotion, name)
3402 __repr__ = _swig_repr
3404 """
3405 MaskedMotion::MaskedMotion(const MaskedMotion &mm)
3406
3407
3408
3409
3410 """
3411 if self.__class__ == MaskedMotion:
3412 args = (None,) + args
3413 else:
3414 args = (self,) + args
3415 this = _Piavca_base.new_MaskedMotion(*args)
3416 try: self.this.append(this)
3417 except: self.this = this
3419 """
3420 virtual bool Piavca::MotionFilter::isNull(int trackId) const
3421
3422 given an iterator tests whether it actually points to anything or if its null
3423
3424
3425 """
3426 return _Piavca_base.MaskedMotion_isNull(*args)
3427
3429 """
3430 trackType Piavca::MotionFilter::getTrackType(int trackId) const
3431
3432 get the type of the track corresponding to an iterator
3433
3434
3435 """
3436 return _Piavca_base.MaskedMotion_getTrackType(*args)
3437
3439 """
3440 virtual Motion* Piavca::MaskedMotion::clone()
3441
3442 creates a copy of the motion
3443
3444
3445 """
3446 return _Piavca_base.MaskedMotion_clone(*args)
3447
3448 - def getClassName(*args): return _Piavca_base.MaskedMotion_getClassName(*args)
3449 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MaskedMotion_castToThisType
3450 if _newclass:castToThisType = staticmethod(_Piavca_base.MaskedMotion_castToThisType)
3451 - def setMask(*args): return _Piavca_base.MaskedMotion_setMask(*args)
3452 - def getMask(*args): return _Piavca_base.MaskedMotion_getMask(*args)
3453 - def addToMask(*args): return _Piavca_base.MaskedMotion_addToMask(*args)
3454 - def removeFromMask(*args): return _Piavca_base.MaskedMotion_removeFromMask(*args)
3455 - def addAllToMask(*args): return _Piavca_base.MaskedMotion_addAllToMask(*args)
3456 - def removeAllFromMask(*args): return _Piavca_base.MaskedMotion_removeAllFromMask(*args)
3458 """
3459 float MaskedMotion::getFloatValueAtTimeInternal(int trackId, float time)
3460
3461 internal version of getFloatValueAtTime, to be overridden
3462
3463
3464 """
3465 return _Piavca_base.MaskedMotion_getFloatValueAtTimeInternal(*args)
3466
3468 """
3469 Vec MaskedMotion::getVecValueAtTimeInternal(int trackId, float time)
3470
3471 internal version of getVecValueAtTime, to be overridden
3472
3473
3474 """
3475 return _Piavca_base.MaskedMotion_getVecValueAtTimeInternal(*args)
3476
3478 """
3479 Quat MaskedMotion::getQuatValueAtTimeInternal(int trackId, float time)
3480
3481 internal version of getQuatValueAtTime, to be overridden
3482
3483
3484 """
3485 return _Piavca_base.MaskedMotion_getQuatValueAtTimeInternal(*args)
3486
3487 __swig_destroy__ = _Piavca_base.delete_MaskedMotion
3488 __del__ = lambda self : None;
3490 self.this.disown()
3491 _Piavca_base.disown_MaskedMotion(self)
3492 return weakref_proxy(self)
3493 MaskedMotion_swigregister = _Piavca_base.MaskedMotion_swigregister
3494 MaskedMotion_swigregister(MaskedMotion)
3495 MaskedMotion_castToThisType = _Piavca_base.MaskedMotion_castToThisType
3496
3498 """
3499 a motion filter that scales the motion by a float factor
3500
3501 see also: ScaleMotion.h
3502 """
3503 __swig_setmethods__ = {}
3504 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3505 __setattr__ = lambda self, name, value: _swig_setattr(self, ScaleMotion, name, value)
3506 __swig_getmethods__ = {}
3507 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3508 __getattr__ = lambda self, name: _swig_getattr(self, ScaleMotion, name)
3509 __repr__ = _swig_repr
3511 """
3512 Piavca::ScaleMotion::ScaleMotion(const ScaleMotion &sm)
3513
3514
3515
3516
3517 """
3518 if self.__class__ == ScaleMotion:
3519 args = (None,) + args
3520 else:
3521 args = (self,) + args
3522 this = _Piavca_base.new_ScaleMotion(*args)
3523 try: self.this.append(this)
3524 except: self.this = this
3526 """
3527 virtual Motion* Piavca::ScaleMotion::clone()
3528
3529 creates a copy of the motion
3530
3531
3532 """
3533 return _Piavca_base.ScaleMotion_clone(*args)
3534
3535 - def getClassName(*args): return _Piavca_base.ScaleMotion_getClassName(*args)
3536 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ScaleMotion_castToThisType
3537 if _newclass:castToThisType = staticmethod(_Piavca_base.ScaleMotion_castToThisType)
3539 """
3540 virtual PIAVCA_EXPORT float Piavca::ScaleMotion::getFloatValueAtTimeInternal(int trackId, float time)
3541
3542 calculates the values of a keyframe
3543
3544
3545 """
3546 return _Piavca_base.ScaleMotion_getFloatValueAtTimeInternal(*args)
3547
3549 """
3550 virtual PIAVCA_EXPORT Vec Piavca::ScaleMotion::getVecValueAtTimeInternal(int trackId, float time)
3551
3552 calculates the values of a keyframe
3553
3554
3555 """
3556 return _Piavca_base.ScaleMotion_getVecValueAtTimeInternal(*args)
3557
3559 """
3560 virtual PIAVCA_EXPORT Quat Piavca::ScaleMotion::getQuatValueAtTimeInternal(int trackId, float time)
3561
3562 calculates the values of a keyframe
3563
3564
3565 """
3566 return _Piavca_base.ScaleMotion_getQuatValueAtTimeInternal(*args)
3567
3569 """
3570 void Piavca::ScaleMotion::setScaleFactor(float scale)
3571
3572 Sets the scale factor for the postion components of the motion.
3573
3574
3575 """
3576 return _Piavca_base.ScaleMotion_setScaleFactor(*args)
3577
3578 - def getScaleFactor(*args): return _Piavca_base.ScaleMotion_getScaleFactor(*args)
3579 __swig_destroy__ = _Piavca_base.delete_ScaleMotion
3580 __del__ = lambda self : None;
3582 self.this.disown()
3583 _Piavca_base.disown_ScaleMotion(self)
3584 return weakref_proxy(self)
3585 ScaleMotion_swigregister = _Piavca_base.ScaleMotion_swigregister
3586 ScaleMotion_swigregister(ScaleMotion)
3587 ScaleMotion_castToThisType = _Piavca_base.ScaleMotion_castToThisType
3588
3590 """
3591 a motion filter that scales the motion's speed
3592
3593 see also: ScaleMotionSpeed.h
3594 """
3595 __swig_setmethods__ = {}
3596 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3597 __setattr__ = lambda self, name, value: _swig_setattr(self, ScaleMotionSpeed, name, value)
3598 __swig_getmethods__ = {}
3599 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3600 __getattr__ = lambda self, name: _swig_getattr(self, ScaleMotionSpeed, name)
3601 __repr__ = _swig_repr
3603 """
3604 Piavca::ScaleMotionSpeed::ScaleMotionSpeed(const ScaleMotionSpeed &sm)
3605
3606
3607
3608
3609 """
3610 if self.__class__ == ScaleMotionSpeed:
3611 args = (None,) + args
3612 else:
3613 args = (self,) + args
3614 this = _Piavca_base.new_ScaleMotionSpeed(*args)
3615 try: self.this.append(this)
3616 except: self.this = this
3618 """
3619 virtual Motion* Piavca::ScaleMotionSpeed::clone()
3620
3621 creates a copy of the motion
3622
3623
3624 """
3625 return _Piavca_base.ScaleMotionSpeed_clone(*args)
3626
3627 - def getClassName(*args): return _Piavca_base.ScaleMotionSpeed_getClassName(*args)
3628 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ScaleMotionSpeed_castToThisType
3629 if _newclass:castToThisType = staticmethod(_Piavca_base.ScaleMotionSpeed_castToThisType)
3631 """
3632 virtual float Piavca::ScaleMotionSpeed::getMotionLength() const
3633
3634 gets the length of the motion in seconds
3635
3636
3637 """
3638 return _Piavca_base.ScaleMotionSpeed_getMotionLength(*args)
3639
3641 """
3642 virtual PIAVCA_EXPORT float Piavca::ScaleMotionSpeed::getFloatValueAtTimeInternal(int trackId, float time)
3643
3644 calculates the values of a keyframe
3645
3646
3647 """
3648 return _Piavca_base.ScaleMotionSpeed_getFloatValueAtTimeInternal(*args)
3649
3651 """
3652 virtual PIAVCA_EXPORT Vec Piavca::ScaleMotionSpeed::getVecValueAtTimeInternal(int trackId, float time)
3653
3654 calculates the values of a keyframe
3655
3656
3657 """
3658 return _Piavca_base.ScaleMotionSpeed_getVecValueAtTimeInternal(*args)
3659
3661 """
3662 virtual PIAVCA_EXPORT Quat Piavca::ScaleMotionSpeed::getQuatValueAtTimeInternal(int trackId, float time)
3663
3664 calculates the values of a keyframe
3665
3666
3667 """
3668 return _Piavca_base.ScaleMotionSpeed_getQuatValueAtTimeInternal(*args)
3669
3671 """
3672 void Piavca::ScaleMotionSpeed::setScaleFactor(float scale)
3673
3674 Sets the scale factor for the postion components of the motion.
3675
3676
3677 """
3678 return _Piavca_base.ScaleMotionSpeed_setScaleFactor(*args)
3679
3680 - def getScaleFactor(*args): return _Piavca_base.ScaleMotionSpeed_getScaleFactor(*args)
3681 __swig_destroy__ = _Piavca_base.delete_ScaleMotionSpeed
3682 __del__ = lambda self : None;
3684 self.this.disown()
3685 _Piavca_base.disown_ScaleMotionSpeed(self)
3686 return weakref_proxy(self)
3687 ScaleMotionSpeed_swigregister = _Piavca_base.ScaleMotionSpeed_swigregister
3688 ScaleMotionSpeed_swigregister(ScaleMotionSpeed)
3689 ScaleMotionSpeed_castToThisType = _Piavca_base.ScaleMotionSpeed_castToThisType
3690
3692 """
3693 see also: ChangeMotionLength.h
3694 """
3695 __swig_setmethods__ = {}
3696 for _s in [ScaleMotionSpeed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3697 __setattr__ = lambda self, name, value: _swig_setattr(self, ChangeMotionLength, name, value)
3698 __swig_getmethods__ = {}
3699 for _s in [ScaleMotionSpeed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3700 __getattr__ = lambda self, name: _swig_getattr(self, ChangeMotionLength, name)
3701 __repr__ = _swig_repr
3703 """
3704 Piavca::ChangeMotionLength::ChangeMotionLength(const ChangeMotionLength &cml)
3705
3706
3707
3708
3709 """
3710 if self.__class__ == ChangeMotionLength:
3711 args = (None,) + args
3712 else:
3713 args = (self,) + args
3714 this = _Piavca_base.new_ChangeMotionLength(*args)
3715 try: self.this.append(this)
3716 except: self.this = this
3718 """
3719 virtual Motion* Piavca::ChangeMotionLength::clone()
3720
3721 creates a copy of the motion
3722
3723
3724 """
3725 return _Piavca_base.ChangeMotionLength_clone(*args)
3726
3727 - def getClassName(*args): return _Piavca_base.ChangeMotionLength_getClassName(*args)
3728 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ChangeMotionLength_castToThisType
3729 if _newclass:castToThisType = staticmethod(_Piavca_base.ChangeMotionLength_castToThisType)
3730 - def setLength(*args): return _Piavca_base.ChangeMotionLength_setLength(*args)
3731 - def getLength(*args): return _Piavca_base.ChangeMotionLength_getLength(*args)
3733 """
3734 virtual float Piavca::ChangeMotionLength::getMotionLength() const
3735
3736 gets the length of the motion in seconds
3737
3738
3739 """
3740 return _Piavca_base.ChangeMotionLength_getMotionLength(*args)
3741
3743 """
3744 virtual void Piavca::ChangeMotionLength::setMotion(Motion *mot)
3745
3746
3747
3748
3749 """
3750 return _Piavca_base.ChangeMotionLength_setMotion(*args)
3751
3752 __swig_destroy__ = _Piavca_base.delete_ChangeMotionLength
3753 __del__ = lambda self : None;
3755 self.this.disown()
3756 _Piavca_base.disown_ChangeMotionLength(self)
3757 return weakref_proxy(self)
3758 ChangeMotionLength_swigregister = _Piavca_base.ChangeMotionLength_swigregister
3759 ChangeMotionLength_swigregister(ChangeMotionLength)
3760 ChangeMotionLength_castToThisType = _Piavca_base.ChangeMotionLength_castToThisType
3761
3763 """
3764 a motion filter that scales the displacement (position) parts of the motion
3765
3766 This is basically useful for converting bvh files that are expressed in feet and inches to metres but might also be useful for motion retargeting. see also: ScaleMotionRoot.h
3767 """
3768 __swig_setmethods__ = {}
3769 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3770 __setattr__ = lambda self, name, value: _swig_setattr(self, ScaleMotionRoot, name, value)
3771 __swig_getmethods__ = {}
3772 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3773 __getattr__ = lambda self, name: _swig_getattr(self, ScaleMotionRoot, name)
3774 __repr__ = _swig_repr
3776 """
3777 Piavca::ScaleMotionRoot::ScaleMotionRoot(const ScaleMotionRoot &sm)
3778
3779
3780
3781
3782 """
3783 if self.__class__ == ScaleMotionRoot:
3784 args = (None,) + args
3785 else:
3786 args = (self,) + args
3787 this = _Piavca_base.new_ScaleMotionRoot(*args)
3788 try: self.this.append(this)
3789 except: self.this = this
3790 __swig_destroy__ = _Piavca_base.delete_ScaleMotionRoot
3791 __del__ = lambda self : None;
3793 """
3794 virtual Motion* Piavca::ScaleMotionRoot::clone()
3795
3796 creates a copy of the motion
3797
3798
3799 """
3800 return _Piavca_base.ScaleMotionRoot_clone(*args)
3801
3802 - def getClassName(*args): return _Piavca_base.ScaleMotionRoot_getClassName(*args)
3803 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ScaleMotionRoot_castToThisType
3804 if _newclass:castToThisType = staticmethod(_Piavca_base.ScaleMotionRoot_castToThisType)
3806 """
3807 virtual PIAVCA_EXPORT float Piavca::ScaleMotionRoot::getFloatValueAtTimeInternal(int trackId, float time)
3808
3809 calculates the values of a keyframe
3810
3811
3812 """
3813 return _Piavca_base.ScaleMotionRoot_getFloatValueAtTimeInternal(*args)
3814
3816 """
3817 virtual PIAVCA_EXPORT Vec Piavca::ScaleMotionRoot::getVecValueAtTimeInternal(int trackId, float time)
3818
3819 calculates the values of a keyframe (vec values are scaled)
3820
3821
3822 """
3823 return _Piavca_base.ScaleMotionRoot_getVecValueAtTimeInternal(*args)
3824
3826 """
3827 virtual PIAVCA_EXPORT Quat Piavca::ScaleMotionRoot::getQuatValueAtTimeInternal(int trackId, float time)
3828
3829 calculates the values of a keyframe
3830
3831
3832 """
3833 return _Piavca_base.ScaleMotionRoot_getQuatValueAtTimeInternal(*args)
3834
3836 """
3837 void Piavca::ScaleMotionRoot::setScaleFactor(float scale)
3838
3839 Sets the scale factor for the postion components of the motion.
3840
3841
3842 """
3843 return _Piavca_base.ScaleMotionRoot_setScaleFactor(*args)
3844
3845 - def getScaleFactor(*args): return _Piavca_base.ScaleMotionRoot_getScaleFactor(*args)
3847 self.this.disown()
3848 _Piavca_base.disown_ScaleMotionRoot(self)
3849 return weakref_proxy(self)
3850 ScaleMotionRoot_swigregister = _Piavca_base.ScaleMotionRoot_swigregister
3851 ScaleMotionRoot_swigregister(ScaleMotionRoot)
3852 ScaleMotionRoot_castToThisType = _Piavca_base.ScaleMotionRoot_castToThisType
3853
3855 """
3856 changes the start time of a motion by an offset
3857
3858 see also: TimeOffset.h
3859 """
3860 __swig_setmethods__ = {}
3861 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3862 __setattr__ = lambda self, name, value: _swig_setattr(self, TimeOffset, name, value)
3863 __swig_getmethods__ = {}
3864 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3865 __getattr__ = lambda self, name: _swig_getattr(self, TimeOffset, name)
3866 __repr__ = _swig_repr
3868 """
3869 Piavca::TimeOffset::TimeOffset(const TimeOffset &to)
3870
3871
3872
3873
3874 """
3875 if self.__class__ == TimeOffset:
3876 args = (None,) + args
3877 else:
3878 args = (self,) + args
3879 this = _Piavca_base.new_TimeOffset(*args)
3880 try: self.this.append(this)
3881 except: self.this = this
3883 """
3884 virtual Motion* Piavca::TimeOffset::clone()
3885
3886 creates a copy of the motion
3887
3888
3889 """
3890 return _Piavca_base.TimeOffset_clone(*args)
3891
3892 - def getClassName(*args): return _Piavca_base.TimeOffset_getClassName(*args)
3893 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.TimeOffset_castToThisType
3894 if _newclass:castToThisType = staticmethod(_Piavca_base.TimeOffset_castToThisType)
3896 """
3897 virtual void Piavca::TimeOffset::setStartTime(float time)
3898
3899 sets the start time of the motion. Called when its loaded into an avatar.
3900
3901
3902 """
3903 return _Piavca_base.TimeOffset_setStartTime(*args)
3904
3906 """
3907 virtual PIAVCA_EXPORT float Piavca::TimeOffset::getFloatValueAtTimeInternal(int trackId, float time)
3908
3909 calculates the values of a keyframe
3910
3911
3912 """
3913 return _Piavca_base.TimeOffset_getFloatValueAtTimeInternal(*args)
3914
3916 """
3917 virtual PIAVCA_EXPORT Vec Piavca::TimeOffset::getVecValueAtTimeInternal(int trackId, float time)
3918
3919 calculates the values of a keyframe (vec values are scaled)
3920
3921
3922 """
3923 return _Piavca_base.TimeOffset_getVecValueAtTimeInternal(*args)
3924
3926 """
3927 virtual PIAVCA_EXPORT Quat Piavca::TimeOffset::getQuatValueAtTimeInternal(int trackId, float time)
3928
3929 calculates the values of a keyframe
3930
3931
3932 """
3933 return _Piavca_base.TimeOffset_getQuatValueAtTimeInternal(*args)
3934
3936 """
3937 void Piavca::TimeOffset::setOffset(float offs)
3938
3939 Sets the scale factor for the postion components of the motion.
3940
3941
3942 """
3943 return _Piavca_base.TimeOffset_setOffset(*args)
3944
3945 - def getOffset(*args): return _Piavca_base.TimeOffset_getOffset(*args)
3946 __swig_destroy__ = _Piavca_base.delete_TimeOffset
3947 __del__ = lambda self : None;
3949 self.this.disown()
3950 _Piavca_base.disown_TimeOffset(self)
3951 return weakref_proxy(self)
3952 TimeOffset_swigregister = _Piavca_base.TimeOffset_swigregister
3953 TimeOffset_swigregister(TimeOffset)
3954 TimeOffset_castToThisType = _Piavca_base.TimeOffset_castToThisType
3955
3957 __swig_setmethods__ = {}
3958 for _s in [TwoMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
3959 __setattr__ = lambda self, name, value: _swig_setattr(self, Sequence, name, value)
3960 __swig_getmethods__ = {}
3961 for _s in [TwoMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
3962 __getattr__ = lambda self, name: _swig_getattr(self, Sequence, name)
3963 __repr__ = _swig_repr
3965 if self.__class__ == Sequence:
3966 args = (None,) + args
3967 else:
3968 args = (self,) + args
3969 this = _Piavca_base.new_Sequence(*args)
3970 try: self.this.append(this)
3971 except: self.this = this
3973 """
3974 virtual Motion* Piavca::Motion::clone()=0
3975
3976 creates a copy of the motion
3977
3978
3979 """
3980 return _Piavca_base.Sequence_clone(*args)
3981
3982 - def getClassName(*args): return _Piavca_base.Sequence_getClassName(*args)
3983 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.Sequence_castToThisType
3984 if _newclass:castToThisType = staticmethod(_Piavca_base.Sequence_castToThisType)
3986 """
3987 void TwoMotionCombiner::setStartTime(float time)
3988
3989 sets the start time of the motion. Called when its loaded into an avatar.
3990
3991
3992 """
3993 return _Piavca_base.Sequence_setStartTime(*args)
3994
3996 """
3997 float TwoMotionCombiner::getMotionLength() const
3998
3999 gets the length of the combined motion (by default the length of the longer of the two)
4000
4001
4002 """
4003 return _Piavca_base.Sequence_getMotionLength(*args)
4004
4008 __swig_destroy__ = _Piavca_base.delete_Sequence
4009 __del__ = lambda self : None;
4011 self.this.disown()
4012 _Piavca_base.disown_Sequence(self)
4013 return weakref_proxy(self)
4014 Sequence_swigregister = _Piavca_base.Sequence_swigregister
4015 Sequence_swigregister(Sequence)
4016 Sequence_castToThisType = _Piavca_base.Sequence_castToThisType
4017
4019 __swig_setmethods__ = {}
4020 for _s in [Sequence]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4021 __setattr__ = lambda self, name, value: _swig_setattr(self, SmoothSequence, name, value)
4022 __swig_getmethods__ = {}
4023 for _s in [Sequence]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4024 __getattr__ = lambda self, name: _swig_getattr(self, SmoothSequence, name)
4025 __repr__ = _swig_repr
4027 this = _Piavca_base.new_SmoothSequence(*args)
4028 try: self.this.append(this)
4029 except: self.this = this
4031 """
4032 virtual Motion* Piavca::Motion::clone()=0
4033
4034 creates a copy of the motion
4035
4036
4037 """
4038 return _Piavca_base.SmoothSequence_clone(*args)
4039
4040 - def getClassName(*args): return _Piavca_base.SmoothSequence_getClassName(*args)
4041 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.SmoothSequence_castToThisType
4042 if _newclass:castToThisType = staticmethod(_Piavca_base.SmoothSequence_castToThisType)
4043 - def create(*args): return _Piavca_base.SmoothSequence_create(*args)
4044 - def setMaintainY(*args): return _Piavca_base.SmoothSequence_setMaintainY(*args)
4045 - def setAccumulateRoot(*args): return _Piavca_base.SmoothSequence_setAccumulateRoot(*args)
4047 """
4048 void TwoMotionCombiner::setMotion1(Motion *mot)
4049
4050
4051
4052
4053 """
4054 return _Piavca_base.SmoothSequence_setMotion1(*args)
4055
4057 """
4058 void TwoMotionCombiner::setMotion2(Motion *mot)
4059
4060
4061
4062
4063 """
4064 return _Piavca_base.SmoothSequence_setMotion2(*args)
4065
4066 - def setBlendStart(*args): return _Piavca_base.SmoothSequence_setBlendStart(*args)
4067 - def setBlendInterval(*args): return _Piavca_base.SmoothSequence_setBlendInterval(*args)
4068 - def getBlendStart(*args): return _Piavca_base.SmoothSequence_getBlendStart(*args)
4069 - def getBlendInterval(*args): return _Piavca_base.SmoothSequence_getBlendInterval(*args)
4070 __swig_destroy__ = _Piavca_base.delete_SmoothSequence
4071 __del__ = lambda self : None;
4072 SmoothSequence_swigregister = _Piavca_base.SmoothSequence_swigregister
4073 SmoothSequence_swigregister(SmoothSequence)
4074 SmoothSequence_castToThisType = _Piavca_base.SmoothSequence_castToThisType
4075
4076 -class MotionPosture(KeyframeMotion):
4077 __swig_setmethods__ = {}
4078 for _s in [KeyframeMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4079 __setattr__ = lambda self, name, value: _swig_setattr(self, MotionPosture, name, value)
4080 __swig_getmethods__ = {}
4081 for _s in [KeyframeMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4082 __getattr__ = lambda self, name: _swig_getattr(self, MotionPosture, name)
4083 __repr__ = _swig_repr
4084 - def __init__(self, *args):
4085 if self.__class__ == MotionPosture:
4086 args = (None,) + args
4087 else:
4088 args = (self,) + args
4089 this = _Piavca_base.new_MotionPosture(*args)
4090 try: self.this.append(this)
4091 except: self.this = this
4093 """
4094 virtual Motion* Piavca::Motion::clone()=0
4095
4096 creates a copy of the motion
4097
4098
4099 """
4100 return _Piavca_base.MotionPosture_clone(*args)
4101
4102 - def getClassName(*args): return _Piavca_base.MotionPosture_getClassName(*args)
4103 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MotionPosture_castToThisType
4104 if _newclass:castToThisType = staticmethod(_Piavca_base.MotionPosture_castToThisType)
4105 - def getPostureFromMotion(*args): return _Piavca_base.MotionPosture_getPostureFromMotion(*args)
4106 __swig_destroy__ = _Piavca_base.delete_MotionPosture
4107 __del__ = lambda self : None;
4108 - def __disown__(self):
4109 self.this.disown()
4110 _Piavca_base.disown_MotionPosture(self)
4111 return weakref_proxy(self)
4112 MotionPosture_swigregister = _Piavca_base.MotionPosture_swigregister
4113 MotionPosture_swigregister(MotionPosture)
4114 MotionPosture_castToThisType = _Piavca_base.MotionPosture_castToThisType
4115
4116 -class AvatarPosture(KeyframeMotion):
4117 __swig_setmethods__ = {}
4118 for _s in [KeyframeMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4119 __setattr__ = lambda self, name, value: _swig_setattr(self, AvatarPosture, name, value)
4120 __swig_getmethods__ = {}
4121 for _s in [KeyframeMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4122 __getattr__ = lambda self, name: _swig_getattr(self, AvatarPosture, name)
4123 __repr__ = _swig_repr
4124 - def __init__(self, *args):
4125 if self.__class__ == AvatarPosture:
4126 args = (None,) + args
4127 else:
4128 args = (self,) + args
4129 this = _Piavca_base.new_AvatarPosture(*args)
4130 try: self.this.append(this)
4131 except: self.this = this
4133 """
4134 virtual Motion* Piavca::Motion::clone()=0
4135
4136 creates a copy of the motion
4137
4138
4139 """
4140 return _Piavca_base.AvatarPosture_clone(*args)
4141
4142 - def getClassName(*args): return _Piavca_base.AvatarPosture_getClassName(*args)
4143 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.AvatarPosture_castToThisType
4144 if _newclass:castToThisType = staticmethod(_Piavca_base.AvatarPosture_castToThisType)
4146 """
4147 virtual void Piavca::Motion::load(Avatar *av)
4148
4149 called when the motion is loaded into an avatar
4150
4151
4152 """
4153 return _Piavca_base.AvatarPosture_load(*args)
4154
4155 - def getPostureFromAvatar(*args): return _Piavca_base.AvatarPosture_getPostureFromAvatar(*args)
4156 __swig_destroy__ = _Piavca_base.delete_AvatarPosture
4157 __del__ = lambda self : None;
4158 - def __disown__(self):
4159 self.this.disown()
4160 _Piavca_base.disown_AvatarPosture(self)
4161 return weakref_proxy(self)
4162 AvatarPosture_swigregister = _Piavca_base.AvatarPosture_swigregister
4163 AvatarPosture_swigregister(AvatarPosture)
4164 AvatarPosture_castToThisType = _Piavca_base.AvatarPosture_castToThisType
4165
4166 -class PostureBlend(Sequence):
4167 __swig_setmethods__ = {}
4168 for _s in [Sequence]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4169 __setattr__ = lambda self, name, value: _swig_setattr(self, PostureBlend, name, value)
4170 __swig_getmethods__ = {}
4171 for _s in [Sequence]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4172 __getattr__ = lambda self, name: _swig_getattr(self, PostureBlend, name)
4173 __repr__ = _swig_repr
4174 - def __init__(self, *args):
4175 if self.__class__ == PostureBlend:
4176 args = (None,) + args
4177 else:
4178 args = (self,) + args
4179 this = _Piavca_base.new_PostureBlend(*args)
4180 try: self.this.append(this)
4181 except: self.this = this
4183 """
4184 virtual Motion* Piavca::Motion::clone()=0
4185
4186 creates a copy of the motion
4187
4188
4189 """
4190 return _Piavca_base.PostureBlend_clone(*args)
4191
4192 - def getClassName(*args): return _Piavca_base.PostureBlend_getClassName(*args)
4193 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.PostureBlend_castToThisType
4194 if _newclass:castToThisType = staticmethod(_Piavca_base.PostureBlend_castToThisType)
4195 - def setBlendInterval(*args): return _Piavca_base.PostureBlend_setBlendInterval(*args)
4196 - def getBlendInterval(*args): return _Piavca_base.PostureBlend_getBlendInterval(*args)
4197 - def setAccumulateRoot(*args): return _Piavca_base.PostureBlend_setAccumulateRoot(*args)
4198 - def getAccumulateRoot(*args): return _Piavca_base.PostureBlend_getAccumulateRoot(*args)
4200 """
4201 void TwoMotionCombiner::reset()
4202
4203 does any resetting needed
4204
4205
4206 """
4207 return _Piavca_base.PostureBlend_reset(*args)
4208
4209 - def reblend(*args): return _Piavca_base.PostureBlend_reblend(*args)
4210 - def setMotion(*args): return _Piavca_base.PostureBlend_setMotion(*args)
4211 - def getMotion(*args): return _Piavca_base.PostureBlend_getMotion(*args)
4212 __swig_destroy__ = _Piavca_base.delete_PostureBlend
4213 __del__ = lambda self : None;
4214 - def __disown__(self):
4215 self.this.disown()
4216 _Piavca_base.disown_PostureBlend(self)
4217 return weakref_proxy(self)
4218 PostureBlend_swigregister = _Piavca_base.PostureBlend_swigregister
4219 PostureBlend_swigregister(PostureBlend)
4220 PostureBlend_castToThisType = _Piavca_base.PostureBlend_castToThisType
4221
4223 __swig_setmethods__ = {}
4224 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4225 __setattr__ = lambda self, name, value: _swig_setattr(self, Reposition, name, value)
4226 __swig_getmethods__ = {}
4227 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4228 __getattr__ = lambda self, name: _swig_getattr(self, Reposition, name)
4229 __repr__ = _swig_repr
4231 if self.__class__ == Reposition:
4232 args = (None,) + args
4233 else:
4234 args = (self,) + args
4235 this = _Piavca_base.new_Reposition(*args)
4236 try: self.this.append(this)
4237 except: self.this = this
4239 """
4240 virtual Motion* Piavca::Motion::clone()=0
4241
4242 creates a copy of the motion
4243
4244
4245 """
4246 return _Piavca_base.Reposition_clone(*args)
4247
4248 - def getClassName(*args): return _Piavca_base.Reposition_getClassName(*args)
4249 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.Reposition_castToThisType
4250 if _newclass:castToThisType = staticmethod(_Piavca_base.Reposition_castToThisType)
4251 - def setStartPosition(*args): return _Piavca_base.Reposition_setStartPosition(*args)
4253 - def setPosOffset(*args): return _Piavca_base.Reposition_setPosOffset(*args)
4254 - def getPosOffset(*args): return _Piavca_base.Reposition_getPosOffset(*args)
4255 - def getStartPosition(*args): return _Piavca_base.Reposition_getStartPosition(*args)
4259 """
4260 void Piavca::MotionFilter::setMotion(Motion *mot)
4261
4262
4263
4264
4265 """
4266 return _Piavca_base.Reposition_setMotion(*args)
4267
4268 - def setMaintainY(*args): return _Piavca_base.Reposition_setMaintainY(*args)
4269 - def setMaintainUp(*args): return _Piavca_base.Reposition_setMaintainUp(*args)
4270 - def getMaintainUp(*args): return _Piavca_base.Reposition_getMaintainUp(*args)
4271 - def setRotateAboutUp(*args): return _Piavca_base.Reposition_setRotateAboutUp(*args)
4272 - def getRotateAboutUp(*args): return _Piavca_base.Reposition_getRotateAboutUp(*args)
4273 - def setUpDirection(*args): return _Piavca_base.Reposition_setUpDirection(*args)
4274 - def getUpDirection(*args): return _Piavca_base.Reposition_getUpDirection(*args)
4276 """
4277 virtual bool Piavca::MotionFilter::isNull(int trackId) const
4278
4279 given an iterator tests whether it actually points to anything or if its null
4280
4281
4282 """
4283 return _Piavca_base.Reposition_isNull(*args)
4284
4286 """
4287 trackType Piavca::MotionFilter::getTrackType(int trackId) const
4288
4289 get the type of the track corresponding to an iterator
4290
4291
4292 """
4293 return _Piavca_base.Reposition_getTrackType(*args)
4294
4296 """
4297 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
4298
4299 internal version of getFloatValueAtTime, to be overridden
4300
4301
4302 """
4303 return _Piavca_base.Reposition_getFloatValueAtTimeInternal(*args)
4304
4306 """
4307 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
4308
4309 internal version of getVecValueAtTime, to be overridden
4310
4311
4312 """
4313 return _Piavca_base.Reposition_getVecValueAtTimeInternal(*args)
4314
4316 """
4317 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
4318
4319 internal version of getQuatValueAtTime, to be overridden
4320
4321
4322 """
4323 return _Piavca_base.Reposition_getQuatValueAtTimeInternal(*args)
4324
4325 __swig_destroy__ = _Piavca_base.delete_Reposition
4326 __del__ = lambda self : None;
4328 self.this.disown()
4329 _Piavca_base.disown_Reposition(self)
4330 return weakref_proxy(self)
4331 Reposition_swigregister = _Piavca_base.Reposition_swigregister
4332 Reposition_swigregister(Reposition)
4333 Reposition_castToThisType = _Piavca_base.Reposition_castToThisType
4334
4336 """
4337 a motion filter that makes a motion loop continuously
4338
4339 see also: LoopMotion.h
4340 """
4341 __swig_setmethods__ = {}
4342 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4343 __setattr__ = lambda self, name, value: _swig_setattr(self, LoopMotion, name, value)
4344 __swig_getmethods__ = {}
4345 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4346 __getattr__ = lambda self, name: _swig_getattr(self, LoopMotion, name)
4347 __repr__ = _swig_repr
4349 """
4350 Piavca::LoopMotion::LoopMotion(const LoopMotion &l)
4351
4352
4353
4354
4355 """
4356 if self.__class__ == LoopMotion:
4357 args = (None,) + args
4358 else:
4359 args = (self,) + args
4360 this = _Piavca_base.new_LoopMotion(*args)
4361 try: self.this.append(this)
4362 except: self.this = this
4364 """
4365 virtual Motion* Piavca::LoopMotion::clone()
4366
4367 creates a copy of the motion
4368
4369
4370 """
4371 return _Piavca_base.LoopMotion_clone(*args)
4372
4373 - def getClassName(*args): return _Piavca_base.LoopMotion_getClassName(*args)
4374 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.LoopMotion_castToThisType
4375 if _newclass:castToThisType = staticmethod(_Piavca_base.LoopMotion_castToThisType)
4377 """
4378 virtual float Piavca::LoopMotion::getMotionLength() const
4379
4380 gets the motion length (transition start + blend interval + length of second motion)
4381
4382
4383 """
4384 return _Piavca_base.LoopMotion_getMotionLength(*args)
4385
4387 """
4388 void Piavca::LoopMotion::setEndTime(float t)
4389
4390
4391
4392
4393 """
4394 return _Piavca_base.LoopMotion_setEndTime(*args)
4395
4397 """
4398 float Piavca::Motion::getEndTime()
4399
4400 returns the end time of the motion
4401
4402
4403 """
4404 return _Piavca_base.LoopMotion_getEndTime(*args)
4405
4406 - def preFrame(*args): return _Piavca_base.LoopMotion_preFrame(*args)
4407 - def handleEvent(*args): return _Piavca_base.LoopMotion_handleEvent(*args)
4409 """
4410 void Piavca::MotionFilter::reset()
4411
4412 does any resetting needed
4413
4414
4415 """
4416 return _Piavca_base.LoopMotion_reset(*args)
4417
4418 __swig_destroy__ = _Piavca_base.delete_LoopMotion
4419 __del__ = lambda self : None;
4421 self.this.disown()
4422 _Piavca_base.disown_LoopMotion(self)
4423 return weakref_proxy(self)
4424 LoopMotion_swigregister = _Piavca_base.LoopMotion_swigregister
4425 LoopMotion_swigregister(LoopMotion)
4426 LoopMotion_castToThisType = _Piavca_base.LoopMotion_castToThisType
4427
4429 __swig_setmethods__ = {}
4430 for _s in [LoopMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4431 __setattr__ = lambda self, name, value: _swig_setattr(self, SmoothLoop, name, value)
4432 __swig_getmethods__ = {}
4433 for _s in [LoopMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4434 __getattr__ = lambda self, name: _swig_getattr(self, SmoothLoop, name)
4435 __repr__ = _swig_repr
4437 this = _Piavca_base.new_SmoothLoop(*args)
4438 try: self.this.append(this)
4439 except: self.this = this
4441 """
4442 virtual Motion* Piavca::LoopMotion::clone()
4443
4444 creates a copy of the motion
4445
4446
4447 """
4448 return _Piavca_base.SmoothLoop_clone(*args)
4449
4450 - def getClassName(*args): return _Piavca_base.SmoothLoop_getClassName(*args)
4451 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.SmoothLoop_castToThisType
4452 if _newclass:castToThisType = staticmethod(_Piavca_base.SmoothLoop_castToThisType)
4454 """
4455 void Piavca::MotionFilter::setMotion(Motion *mot)
4456
4457
4458
4459
4460 """
4461 return _Piavca_base.SmoothLoop_setMotion(*args)
4462
4463 - def getMotion(*args): return _Piavca_base.SmoothLoop_getMotion(*args)
4464 - def setAccumulateRoot(*args): return _Piavca_base.SmoothLoop_setAccumulateRoot(*args)
4465 - def getAccumulateRoot(*args): return _Piavca_base.SmoothLoop_getAccumulateRoot(*args)
4466 - def setBlendInterval(*args): return _Piavca_base.SmoothLoop_setBlendInterval(*args)
4467 - def getBlendInterval(*args): return _Piavca_base.SmoothLoop_getBlendInterval(*args)
4468 __swig_destroy__ = _Piavca_base.delete_SmoothLoop
4469 __del__ = lambda self : None;
4470 SmoothLoop_swigregister = _Piavca_base.SmoothLoop_swigregister
4471 SmoothLoop_swigregister(SmoothLoop)
4472 SmoothLoop_castToThisType = _Piavca_base.SmoothLoop_castToThisType
4473
4475 __swig_setmethods__ = {}
4476 for _s in [ScaleMotionSpeed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4477 __setattr__ = lambda self, name, value: _swig_setattr(self, RandomTimingsMotion, name, value)
4478 __swig_getmethods__ = {}
4479 for _s in [ScaleMotionSpeed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4480 __getattr__ = lambda self, name: _swig_getattr(self, RandomTimingsMotion, name)
4481 __repr__ = _swig_repr
4483 if self.__class__ == RandomTimingsMotion:
4484 args = (None,) + args
4485 else:
4486 args = (self,) + args
4487 this = _Piavca_base.new_RandomTimingsMotion(*args)
4488 try: self.this.append(this)
4489 except: self.this = this
4490 __swig_destroy__ = _Piavca_base.delete_RandomTimingsMotion
4491 __del__ = lambda self : None;
4493 """
4494 virtual Motion* Piavca::ScaleMotionSpeed::clone()
4495
4496 creates a copy of the motion
4497
4498
4499 """
4500 return _Piavca_base.RandomTimingsMotion_clone(*args)
4501
4502 - def getClassName(*args): return _Piavca_base.RandomTimingsMotion_getClassName(*args)
4503 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.RandomTimingsMotion_castToThisType
4504 if _newclass:castToThisType = staticmethod(_Piavca_base.RandomTimingsMotion_castToThisType)
4505 - def setTimingParams(*args): return _Piavca_base.RandomTimingsMotion_setTimingParams(*args)
4506 - def setMinTimeScale(*args): return _Piavca_base.RandomTimingsMotion_setMinTimeScale(*args)
4507 - def getMinTimeScale(*args): return _Piavca_base.RandomTimingsMotion_getMinTimeScale(*args)
4508 - def setMaxTimeScale(*args): return _Piavca_base.RandomTimingsMotion_setMaxTimeScale(*args)
4509 - def getMaxTimeScale(*args): return _Piavca_base.RandomTimingsMotion_getMaxTimeScale(*args)
4511 """
4512 void Piavca::MotionFilter::reset()
4513
4514 does any resetting needed
4515
4516
4517 """
4518 return _Piavca_base.RandomTimingsMotion_reset(*args)
4519
4521 self.this.disown()
4522 _Piavca_base.disown_RandomTimingsMotion(self)
4523 return weakref_proxy(self)
4524 RandomTimingsMotion_swigregister = _Piavca_base.RandomTimingsMotion_swigregister
4525 RandomTimingsMotion_swigregister(RandomTimingsMotion)
4526 RandomTimingsMotion_castToThisType = _Piavca_base.RandomTimingsMotion_castToThisType
4527
4528 -class AvatarPostureBlend(Sequence):
4529 """
4530 A motion blend operator that blends a motion into the current position of an avatar.
4531
4532 This class will blend smoothly from the current postion of an avatar to the motion and will have the motion start at the current position and orientation of the avatar rather than its own start point (see SequentialBlend docs for some details) see also: AvatarPostureBlend.h
4533 """
4534 __swig_setmethods__ = {}
4535 for _s in [Sequence]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4536 __setattr__ = lambda self, name, value: _swig_setattr(self, AvatarPostureBlend, name, value)
4537 __swig_getmethods__ = {}
4538 for _s in [Sequence]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4539 __getattr__ = lambda self, name: _swig_getattr(self, AvatarPostureBlend, name)
4540 __repr__ = _swig_repr
4541 - def __init__(self, *args):
4542 """
4543 Piavca::AvatarPostureBlend::AvatarPostureBlend(const AvatarPostureBlend &apb)
4544
4545
4546
4547
4548 """
4549 this = _Piavca_base.new_AvatarPostureBlend(*args)
4550 try: self.this.append(this)
4551 except: self.this = this
4553 """
4554 virtual Motion* Piavca::AvatarPostureBlend::clone()
4555
4556 creates a copy of the motion
4557
4558
4559 """
4560 return _Piavca_base.AvatarPostureBlend_clone(*args)
4561
4562 - def getClassName(*args): return _Piavca_base.AvatarPostureBlend_getClassName(*args)
4563 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.AvatarPostureBlend_castToThisType
4564 if _newclass:castToThisType = staticmethod(_Piavca_base.AvatarPostureBlend_castToThisType)
4566 """
4567 void AvatarPostureBlend::load(Avatar *av)
4568
4569 called when the motion is loaded into an avatar
4570
4571
4572 """
4573 return _Piavca_base.AvatarPostureBlend_load(*args)
4574
4575 - def setBlendInterval(*args): return _Piavca_base.AvatarPostureBlend_setBlendInterval(*args)
4576 - def getBlendInterval(*args): return _Piavca_base.AvatarPostureBlend_getBlendInterval(*args)
4577 - def isNull(*args):
4578 """
4579 bool TwoMotionCombiner::isNull(int trackId) const
4580
4581 given a track ID tests whether it actually points to anything or if its null
4582
4583 is null if the track is null in both motions.
4584 """
4585 return _Piavca_base.AvatarPostureBlend_isNull(*args)
4586
4587 - def setMotion(*args):
4588 """
4589 void AvatarPostureBlend::setMotion(Motion *mot)
4590
4591
4592
4593
4594 """
4595 return _Piavca_base.AvatarPostureBlend_setMotion(*args)
4596
4597 - def getMotion(*args): return _Piavca_base.AvatarPostureBlend_getMotion(*args)
4598 - def repositionRelative(*args): return _Piavca_base.AvatarPostureBlend_repositionRelative(*args)
4599 - def repositionAbsolute(*args): return _Piavca_base.AvatarPostureBlend_repositionAbsolute(*args)
4600 - def reblend(*args):
4601 """
4602 void AvatarPostureBlend::reblend(float time)
4603
4604 restart the blend (i.e. start blending from the current avatar posture) at the current time
4605
4606
4607 """
4608 return _Piavca_base.AvatarPostureBlend_reblend(*args)
4609
4610 __swig_destroy__ = _Piavca_base.delete_AvatarPostureBlend
4611 __del__ = lambda self : None;
4612 AvatarPostureBlend_swigregister = _Piavca_base.AvatarPostureBlend_swigregister
4613 AvatarPostureBlend_swigregister(AvatarPostureBlend)
4614 AvatarPostureBlend_castToThisType = _Piavca_base.AvatarPostureBlend_castToThisType
4615
4617 """
4618 A motion manipulator class that interpolates between two motions.
4619
4620 The resulting motion is an interpolation between the two motion using slerp for quaternions with a parameter value blend. This class blends the two motions concurrently rather blending from one to another as sequential blend does. see also: BlendBetween.h
4621 """
4622 __swig_setmethods__ = {}
4623 for _s in [TwoMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4624 __setattr__ = lambda self, name, value: _swig_setattr(self, BlendBetween, name, value)
4625 __swig_getmethods__ = {}
4626 for _s in [TwoMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4627 __getattr__ = lambda self, name: _swig_getattr(self, BlendBetween, name)
4628 __repr__ = _swig_repr
4630 """
4631 BlendBetween::BlendBetween(const BlendBetween &b)
4632
4633
4634
4635
4636 """
4637 if self.__class__ == BlendBetween:
4638 args = (None,) + args
4639 else:
4640 args = (self,) + args
4641 this = _Piavca_base.new_BlendBetween(*args)
4642 try: self.this.append(this)
4643 except: self.this = this
4645 """
4646 virtual Motion* Piavca::BlendBetween::clone()
4647
4648 creates a copy of the motion
4649
4650
4651 """
4652 return _Piavca_base.BlendBetween_clone(*args)
4653
4654 - def getClassName(*args): return _Piavca_base.BlendBetween_getClassName(*args)
4655 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.BlendBetween_castToThisType
4656 if _newclass:castToThisType = staticmethod(_Piavca_base.BlendBetween_castToThisType)
4661 """
4662 void Piavca::BlendBetween::setBlendFactor(float _blend)
4663
4664
4665
4666
4667 """
4668 return _Piavca_base.BlendBetween_setBlendFactor(*args)
4669
4670 - def getBlendFactor(*args): return _Piavca_base.BlendBetween_getBlendFactor(*args)
4671 __swig_destroy__ = _Piavca_base.delete_BlendBetween
4672 __del__ = lambda self : None;
4674 self.this.disown()
4675 _Piavca_base.disown_BlendBetween(self)
4676 return weakref_proxy(self)
4677 BlendBetween_swigregister = _Piavca_base.BlendBetween_swigregister
4678 BlendBetween_swigregister(BlendBetween)
4679 BlendBetween_castToThisType = _Piavca_base.BlendBetween_castToThisType
4680
4682 """
4683 Adds the result of two motions, performing them simultaneously.
4684
4685 The results is the sum of the effects of both motions (in fact with rotations this is achieved with quaternion multiplication but the effect is similar to vector addition. An optional parameter can scale the effect of the second motion. see also: MotionAdder.h
4686 """
4687 __swig_setmethods__ = {}
4688 for _s in [MultiMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4689 __setattr__ = lambda self, name, value: _swig_setattr(self, MotionAdder, name, value)
4690 __swig_getmethods__ = {}
4691 for _s in [MultiMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4692 __getattr__ = lambda self, name: _swig_getattr(self, MotionAdder, name)
4693 __repr__ = _swig_repr
4695 """
4696 Piavca::MotionAdder::MotionAdder(const MotionAdder &ma)
4697
4698
4699
4700
4701 """
4702 if self.__class__ == MotionAdder:
4703 args = (None,) + args
4704 else:
4705 args = (self,) + args
4706 this = _Piavca_base.new_MotionAdder(*args)
4707 try: self.this.append(this)
4708 except: self.this = this
4710 """
4711 virtual Motion* Piavca::MotionAdder::clone()
4712
4713 creates a copy of the motion
4714
4715
4716 """
4717 return _Piavca_base.MotionAdder_clone(*args)
4718
4719 - def getClassName(*args): return _Piavca_base.MotionAdder_getClassName(*args)
4720 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MotionAdder_castToThisType
4721 if _newclass:castToThisType = staticmethod(_Piavca_base.MotionAdder_castToThisType)
4723 """
4724 float MotionAdder::getFloatValueAtTimeInternal(int trackId, float time)
4725
4726 calculates the values of a keyframe
4727
4728 The results is the sum of the two motions.
4729 """
4730 return _Piavca_base.MotionAdder_getFloatValueAtTimeInternal(*args)
4731
4733 """
4734 Vec MotionAdder::getVecValueAtTimeInternal(int trackId, float time)
4735
4736 calculates the values of a keyframe
4737
4738 The results is the sum of the two motions.
4739 """
4740 return _Piavca_base.MotionAdder_getVecValueAtTimeInternal(*args)
4741
4743 """
4744 Quat MotionAdder::getQuatValueAtTimeInternal(int trackId, float time)
4745
4746 calculates the values of a keyframe
4747
4748 The results is the quaternion multiplication of the two motions (which is similar to vector addition).
4749 """
4750 return _Piavca_base.MotionAdder_getQuatValueAtTimeInternal(*args)
4751
4752 __swig_destroy__ = _Piavca_base.delete_MotionAdder
4753 __del__ = lambda self : None;
4755 self.this.disown()
4756 _Piavca_base.disown_MotionAdder(self)
4757 return weakref_proxy(self)
4758 MotionAdder_swigregister = _Piavca_base.MotionAdder_swigregister
4759 MotionAdder_swigregister(MotionAdder)
4760 MotionAdder_castToThisType = _Piavca_base.MotionAdder_castToThisType
4761
4763 __swig_setmethods__ = {}
4764 for _s in [MultiMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4765 __setattr__ = lambda self, name, value: _swig_setattr(self, MultiBlend, name, value)
4766 __swig_getmethods__ = {}
4767 for _s in [MultiMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4768 __getattr__ = lambda self, name: _swig_getattr(self, MultiBlend, name)
4769 __repr__ = _swig_repr
4771 if self.__class__ == MultiBlend:
4772 args = (None,) + args
4773 else:
4774 args = (self,) + args
4775 this = _Piavca_base.new_MultiBlend(*args)
4776 try: self.this.append(this)
4777 except: self.this = this
4779 """
4780 virtual Motion* Piavca::Motion::clone()=0
4781
4782 creates a copy of the motion
4783
4784
4785 """
4786 return _Piavca_base.MultiBlend_clone(*args)
4787
4788 - def getClassName(*args): return _Piavca_base.MultiBlend_getClassName(*args)
4789 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MultiBlend_castToThisType
4790 if _newclass:castToThisType = staticmethod(_Piavca_base.MultiBlend_castToThisType)
4793 - def setWeight(*args): return _Piavca_base.MultiBlend_setWeight(*args)
4794 - def getWeight(*args): return _Piavca_base.MultiBlend_getWeight(*args)
4795 - def setWeightId(*args): return _Piavca_base.MultiBlend_setWeightId(*args)
4797 """
4798 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
4799
4800 internal version of getFloatValueAtTime, to be overridden
4801
4802
4803 """
4804 return _Piavca_base.MultiBlend_getFloatValueAtTimeInternal(*args)
4805
4807 """
4808 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
4809
4810 internal version of getVecValueAtTime, to be overridden
4811
4812
4813 """
4814 return _Piavca_base.MultiBlend_getVecValueAtTimeInternal(*args)
4815
4817 """
4818 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
4819
4820 internal version of getQuatValueAtTime, to be overridden
4821
4822
4823 """
4824 return _Piavca_base.MultiBlend_getQuatValueAtTimeInternal(*args)
4825
4826 __swig_destroy__ = _Piavca_base.delete_MultiBlend
4827 __del__ = lambda self : None;
4829 self.this.disown()
4830 _Piavca_base.disown_MultiBlend(self)
4831 return weakref_proxy(self)
4832 MultiBlend_swigregister = _Piavca_base.MultiBlend_swigregister
4833 MultiBlend_swigregister(MultiBlend)
4834 MultiBlend_castToThisType = _Piavca_base.MultiBlend_castToThisType
4835
4837 __swig_setmethods__ = {}
4838 for _s in [TwoMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4839 __setattr__ = lambda self, name, value: _swig_setattr(self, Subtract, name, value)
4840 __swig_getmethods__ = {}
4841 for _s in [TwoMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4842 __getattr__ = lambda self, name: _swig_getattr(self, Subtract, name)
4843 __repr__ = _swig_repr
4845 if self.__class__ == Subtract:
4846 args = (None,) + args
4847 else:
4848 args = (self,) + args
4849 this = _Piavca_base.new_Subtract(*args)
4850 try: self.this.append(this)
4851 except: self.this = this
4853 """
4854 virtual Motion* Piavca::Motion::clone()=0
4855
4856 creates a copy of the motion
4857
4858
4859 """
4860 return _Piavca_base.Subtract_clone(*args)
4861
4862 - def getClassName(*args): return _Piavca_base.Subtract_getClassName(*args)
4863 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.Subtract_castToThisType
4864 if _newclass:castToThisType = staticmethod(_Piavca_base.Subtract_castToThisType)
4866 """
4867 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
4868
4869 internal version of getFloatValueAtTime, to be overridden
4870
4871
4872 """
4873 return _Piavca_base.Subtract_getFloatValueAtTimeInternal(*args)
4874
4876 """
4877 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
4878
4879 internal version of getVecValueAtTime, to be overridden
4880
4881
4882 """
4883 return _Piavca_base.Subtract_getVecValueAtTimeInternal(*args)
4884
4886 """
4887 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
4888
4889 internal version of getQuatValueAtTime, to be overridden
4890
4891
4892 """
4893 return _Piavca_base.Subtract_getQuatValueAtTimeInternal(*args)
4894
4895 __swig_destroy__ = _Piavca_base.delete_Subtract
4896 __del__ = lambda self : None;
4898 self.this.disown()
4899 _Piavca_base.disown_Subtract(self)
4900 return weakref_proxy(self)
4901 Subtract_swigregister = _Piavca_base.Subtract_swigregister
4902 Subtract_swigregister(Subtract)
4903 Subtract_castToThisType = _Piavca_base.Subtract_castToThisType
4904
4915 TransitionFunction_swigregister = _Piavca_base.TransitionFunction_swigregister
4916 TransitionFunction_swigregister(TransitionFunction)
4917
4919 __swig_setmethods__ = {}
4920 for _s in [TransitionFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4921 __setattr__ = lambda self, name, value: _swig_setattr(self, LinearTransition, name, value)
4922 __swig_getmethods__ = {}
4923 for _s in [TransitionFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4924 __getattr__ = lambda self, name: _swig_getattr(self, LinearTransition, name)
4925 __repr__ = _swig_repr
4927 this = _Piavca_base.new_LinearTransition(*args)
4928 try: self.this.append(this)
4929 except: self.this = this
4930 - def eval(*args): return _Piavca_base.LinearTransition_eval(*args)
4931 __swig_destroy__ = _Piavca_base.delete_LinearTransition
4932 __del__ = lambda self : None;
4933 LinearTransition_swigregister = _Piavca_base.LinearTransition_swigregister
4934 LinearTransition_swigregister(LinearTransition)
4935
4937 __swig_setmethods__ = {}
4938 for _s in [TransitionFunction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4939 __setattr__ = lambda self, name, value: _swig_setattr(self, SmoothTransition, name, value)
4940 __swig_getmethods__ = {}
4941 for _s in [TransitionFunction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4942 __getattr__ = lambda self, name: _swig_getattr(self, SmoothTransition, name)
4943 __repr__ = _swig_repr
4945 this = _Piavca_base.new_SmoothTransition(*args)
4946 try: self.this.append(this)
4947 except: self.this = this
4948 - def eval(*args): return _Piavca_base.SmoothTransition_eval(*args)
4949 __swig_destroy__ = _Piavca_base.delete_SmoothTransition
4950 __del__ = lambda self : None;
4951 SmoothTransition_swigregister = _Piavca_base.SmoothTransition_swigregister
4952 SmoothTransition_swigregister(SmoothTransition)
4953
4955 __swig_setmethods__ = {}
4956 for _s in [TwoMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
4957 __setattr__ = lambda self, name, value: _swig_setattr(self, MotionTransition, name, value)
4958 __swig_getmethods__ = {}
4959 for _s in [TwoMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
4960 __getattr__ = lambda self, name: _swig_getattr(self, MotionTransition, name)
4961 __repr__ = _swig_repr
4963 this = _Piavca_base.new_MotionTransition(*args)
4964 try: self.this.append(this)
4965 except: self.this = this
4967 """
4968 virtual Motion* Piavca::Motion::clone()=0
4969
4970 creates a copy of the motion
4971
4972
4973 """
4974 return _Piavca_base.MotionTransition_clone(*args)
4975
4976 - def getClassName(*args): return _Piavca_base.MotionTransition_getClassName(*args)
4977 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MotionTransition_castToThisType
4978 if _newclass:castToThisType = staticmethod(_Piavca_base.MotionTransition_castToThisType)
4979 MotionStart = _Piavca_base.MotionTransition_MotionStart
4980 MotionEnd = _Piavca_base.MotionTransition_MotionEnd
4982 - def setTransitionTime1(*args): return _Piavca_base.MotionTransition_setTransitionTime1(*args)
4983 - def getTransitionTime1(*args): return _Piavca_base.MotionTransition_getTransitionTime1(*args)
4984 - def setTransitionTime2(*args): return _Piavca_base.MotionTransition_setTransitionTime2(*args)
4985 - def getTransitionTime2(*args): return _Piavca_base.MotionTransition_getTransitionTime2(*args)
4986 - def setWindow(*args): return _Piavca_base.MotionTransition_setWindow(*args)
4987 - def getWindow(*args): return _Piavca_base.MotionTransition_getWindow(*args)
4989 """
4990 void TwoMotionCombiner::setMotion1(Motion *mot)
4991
4992
4993
4994
4995 """
4996 return _Piavca_base.MotionTransition_setMotion1(*args)
4997
4999 """
5000 void TwoMotionCombiner::setStartTime(float time)
5001
5002 sets the start time of the motion. Called when its loaded into an avatar.
5003
5004
5005 """
5006 return _Piavca_base.MotionTransition_setStartTime(*args)
5007
5009 - def getCombinedVecValue(*args): return _Piavca_base.MotionTransition_getCombinedVecValue(*args)
5011 __swig_destroy__ = _Piavca_base.delete_MotionTransition
5012 __del__ = lambda self : None;
5013 MotionTransition_swigregister = _Piavca_base.MotionTransition_swigregister
5014 MotionTransition_swigregister(MotionTransition)
5015 MotionTransition_castToThisType = _Piavca_base.MotionTransition_castToThisType
5016
5018 __swig_setmethods__ = {}
5019 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5020 __setattr__ = lambda self, name, value: _swig_setattr(self, ChoiceMotion, name, value)
5021 __swig_getmethods__ = {}
5022 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5023 __getattr__ = lambda self, name: _swig_getattr(self, ChoiceMotion, name)
5024 __repr__ = _swig_repr
5025 - def updateListeners(*args): return _Piavca_base.ChoiceMotion_updateListeners(*args)
5027 if self.__class__ == ChoiceMotion:
5028 args = (None,) + args
5029 else:
5030 args = (self,) + args
5031 this = _Piavca_base.new_ChoiceMotion(*args)
5032 try: self.this.append(this)
5033 except: self.this = this
5034 __swig_destroy__ = _Piavca_base.delete_ChoiceMotion
5035 __del__ = lambda self : None;
5037 """
5038 virtual Motion* Piavca::Motion::clone()=0
5039
5040 creates a copy of the motion
5041
5042
5043 """
5044 return _Piavca_base.ChoiceMotion_clone(*args)
5045
5046 - def getClassName(*args): return _Piavca_base.ChoiceMotion_getClassName(*args)
5047 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ChoiceMotion_castToThisType
5048 if _newclass:castToThisType = staticmethod(_Piavca_base.ChoiceMotion_castToThisType)
5049 - def setSmooth(*args): return _Piavca_base.ChoiceMotion_setSmooth(*args)
5050 - def getSmooth(*args): return _Piavca_base.ChoiceMotion_getSmooth(*args)
5051 - def setResetTime(*args): return _Piavca_base.ChoiceMotion_setResetTime(*args)
5052 - def getResetTime(*args): return _Piavca_base.ChoiceMotion_getResetTime(*args)
5053 - def setWindowLength(*args): return _Piavca_base.ChoiceMotion_setWindowLength(*args)
5054 - def getWindowLength(*args): return _Piavca_base.ChoiceMotion_getWindowLength(*args)
5055 - def setResetOnEvent(*args): return _Piavca_base.ChoiceMotion_setResetOnEvent(*args)
5056 - def getResetOnEvent(*args): return _Piavca_base.ChoiceMotion_getResetOnEvent(*args)
5057 - def setResetOnPlay(*args): return _Piavca_base.ChoiceMotion_setResetOnPlay(*args)
5058 - def getResetOnPlay(*args): return _Piavca_base.ChoiceMotion_getResetOnPlay(*args)
5061 - def setAccumulateRoot(*args): return _Piavca_base.ChoiceMotion_setAccumulateRoot(*args)
5062 - def getAccumulateRoot(*args): return _Piavca_base.ChoiceMotion_getAccumulateRoot(*args)
5063 - def setMaintainUp(*args): return _Piavca_base.ChoiceMotion_setMaintainUp(*args)
5064 - def getMaintainUp(*args): return _Piavca_base.ChoiceMotion_getMaintainUp(*args)
5065 - def setRotateAboutUp(*args): return _Piavca_base.ChoiceMotion_setRotateAboutUp(*args)
5066 - def getRotateAboutUp(*args): return _Piavca_base.ChoiceMotion_getRotateAboutUp(*args)
5067 - def setUpDirection(*args): return _Piavca_base.ChoiceMotion_setUpDirection(*args)
5068 - def getUpDirection(*args): return _Piavca_base.ChoiceMotion_getUpDirection(*args)
5070 """
5071 void Piavca::MotionFilter::printInfo()
5072
5073 prints out info about the motion heirarchy
5074
5075
5076 """
5077 return _Piavca_base.ChoiceMotion_printInfo(*args)
5078
5079 - def getNumListeners(*args): return _Piavca_base.ChoiceMotion_getNumListeners(*args)
5080 - def addListener(*args): return _Piavca_base.ChoiceMotion_addListener(*args)
5081 - def getListener(*args): return _Piavca_base.ChoiceMotion_getListener(*args)
5083 """
5084 float Piavca::MotionFilter::getMotionLength() const
5085
5086 gets the length of the motion in seconds
5087
5088
5089 """
5090 return _Piavca_base.ChoiceMotion_getMotionLength(*args)
5091
5092 - def addMotion(*args): return _Piavca_base.ChoiceMotion_addMotion(*args)
5093 - def getMotionIndex(*args): return _Piavca_base.ChoiceMotion_getMotionIndex(*args)
5094 - def getNumMotions(*args): return _Piavca_base.ChoiceMotion_getNumMotions(*args)
5095 - def getMotionByIndex(*args): return _Piavca_base.ChoiceMotion_getMotionByIndex(*args)
5096 - def getLeafMotion(*args): return _Piavca_base.ChoiceMotion_getLeafMotion(*args)
5097 - def getMotion(*args): return _Piavca_base.ChoiceMotion_getMotion(*args)
5099 - def clear(*args): return _Piavca_base.ChoiceMotion_clear(*args)
5101 """
5102 virtual Motion* Piavca::MotionFilter::findSub(tstring nm)
5103
5104 finds the first submotion with a given name
5105
5106
5107 """
5108 return _Piavca_base.ChoiceMotion_findSub(*args)
5109
5111 """
5112 virtual Motion* Piavca::MotionFilter::findSubByType(const type_info &ty)
5113
5114 finds the first submotion with a given type
5115
5116
5117 """
5118 return _Piavca_base.ChoiceMotion_findSubByType(*args)
5119
5121 - def setChoice(*args): return _Piavca_base.ChoiceMotion_setChoice(*args)
5122 - def getCurrentChoice(*args): return _Piavca_base.ChoiceMotion_getCurrentChoice(*args)
5123 - def makeChoice(*args): return _Piavca_base.ChoiceMotion_makeChoice(*args)
5124 - def handleEvent(*args): return _Piavca_base.ChoiceMotion_handleEvent(*args)
5125 - def canHandleEvent(*args): return _Piavca_base.ChoiceMotion_canHandleEvent(*args)
5126 - def getEventNames(*args): return _Piavca_base.ChoiceMotion_getEventNames(*args)
5128 """
5129 void Piavca::MotionFilter::reset()
5130
5131 does any resetting needed
5132
5133
5134 """
5135 return _Piavca_base.ChoiceMotion_reset(*args)
5136
5138 self.this.disown()
5139 _Piavca_base.disown_ChoiceMotion(self)
5140 return weakref_proxy(self)
5141 ChoiceMotion_swigregister = _Piavca_base.ChoiceMotion_swigregister
5142 ChoiceMotion_swigregister(ChoiceMotion)
5143 ChoiceMotion_castToThisType = _Piavca_base.ChoiceMotion_castToThisType
5144
5146 __swig_setmethods__ = {}
5147 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5148 __setattr__ = lambda self, name, value: _swig_setattr(self, ChoiceMotionWithDefault, name, value)
5149 __swig_getmethods__ = {}
5150 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5151 __getattr__ = lambda self, name: _swig_getattr(self, ChoiceMotionWithDefault, name)
5152 __repr__ = _swig_repr
5154 this = _Piavca_base.new_ChoiceMotionWithDefault(*args)
5155 try: self.this.append(this)
5156 except: self.this = this
5157 __swig_destroy__ = _Piavca_base.delete_ChoiceMotionWithDefault
5158 __del__ = lambda self : None;
5159 - def clone(*args): return _Piavca_base.ChoiceMotionWithDefault_clone(*args)
5160 - def getClassName(*args): return _Piavca_base.ChoiceMotionWithDefault_getClassName(*args)
5161 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ChoiceMotionWithDefault_castToThisType
5162 if _newclass:castToThisType = staticmethod(_Piavca_base.ChoiceMotionWithDefault_castToThisType)
5164 """
5165 void Piavca::MotionFilter::reset()
5166
5167 does any resetting needed
5168
5169
5170 """
5171 return _Piavca_base.ChoiceMotionWithDefault_reset(*args)
5172
5173 ChoiceMotionWithDefault_swigregister = _Piavca_base.ChoiceMotionWithDefault_swigregister
5174 ChoiceMotionWithDefault_swigregister(ChoiceMotionWithDefault)
5175 ChoiceMotionWithDefault_castToThisType = _Piavca_base.ChoiceMotionWithDefault_castToThisType
5176
5178 __swig_setmethods__ = {}
5179 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5180 __setattr__ = lambda self, name, value: _swig_setattr(self, EventMapChoice, name, value)
5181 __swig_getmethods__ = {}
5182 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5183 __getattr__ = lambda self, name: _swig_getattr(self, EventMapChoice, name)
5184 __repr__ = _swig_repr
5186 if self.__class__ == EventMapChoice:
5187 args = (None,) + args
5188 else:
5189 args = (self,) + args
5190 this = _Piavca_base.new_EventMapChoice(*args)
5191 try: self.this.append(this)
5192 except: self.this = this
5193 __swig_destroy__ = _Piavca_base.delete_EventMapChoice
5194 __del__ = lambda self : None;
5196 """
5197 virtual Motion* Piavca::Motion::clone()=0
5198
5199 creates a copy of the motion
5200
5201
5202 """
5203 return _Piavca_base.EventMapChoice_clone(*args)
5204
5205 - def getClassName(*args): return _Piavca_base.EventMapChoice_getClassName(*args)
5206 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.EventMapChoice_castToThisType
5207 if _newclass:castToThisType = staticmethod(_Piavca_base.EventMapChoice_castToThisType)
5208 __swig_getmethods__["convertTo"] = lambda x: _Piavca_base.EventMapChoice_convertTo
5209 if _newclass:convertTo = staticmethod(_Piavca_base.EventMapChoice_convertTo)
5210 - def addMapItem(*args): return _Piavca_base.EventMapChoice_addMapItem(*args)
5211 - def handleEvent(*args): return _Piavca_base.EventMapChoice_handleEvent(*args)
5212 - def canHandleEvent(*args): return _Piavca_base.EventMapChoice_canHandleEvent(*args)
5214 self.this.disown()
5215 _Piavca_base.disown_EventMapChoice(self)
5216 return weakref_proxy(self)
5217 - def updateListeners(*args): return _Piavca_base.EventMapChoice_updateListeners(*args)
5218 EventMapChoice_swigregister = _Piavca_base.EventMapChoice_swigregister
5219 EventMapChoice_swigregister(EventMapChoice)
5220 EventMapChoice_castToThisType = _Piavca_base.EventMapChoice_castToThisType
5221 EventMapChoice_convertTo = _Piavca_base.EventMapChoice_convertTo
5222
5224 __swig_setmethods__ = {}
5225 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5226 __setattr__ = lambda self, name, value: _swig_setattr(self, SequentialChoiceMotion, name, value)
5227 __swig_getmethods__ = {}
5228 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5229 __getattr__ = lambda self, name: _swig_getattr(self, SequentialChoiceMotion, name)
5230 __repr__ = _swig_repr
5232 this = _Piavca_base.new_SequentialChoiceMotion(*args)
5233 try: self.this.append(this)
5234 except: self.this = this
5235 __swig_destroy__ = _Piavca_base.delete_SequentialChoiceMotion
5236 __del__ = lambda self : None;
5238 """
5239 virtual Motion* Piavca::Motion::clone()=0
5240
5241 creates a copy of the motion
5242
5243
5244 """
5245 return _Piavca_base.SequentialChoiceMotion_clone(*args)
5246
5247 - def getClassName(*args): return _Piavca_base.SequentialChoiceMotion_getClassName(*args)
5248 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.SequentialChoiceMotion_castToThisType
5249 if _newclass:castToThisType = staticmethod(_Piavca_base.SequentialChoiceMotion_castToThisType)
5251 """
5252 virtual void Piavca::MotionFilter::setStartTime(float time)
5253
5254 sets the start time of the motion. Called when its loaded into an avatar.
5255
5256
5257 """
5258 return _Piavca_base.SequentialChoiceMotion_setStartTime(*args)
5259
5262 - def handleEvent(*args): return _Piavca_base.SequentialChoiceMotion_handleEvent(*args)
5263 - def canHandleEvent(*args): return _Piavca_base.SequentialChoiceMotion_canHandleEvent(*args)
5264 - def getEventNames(*args): return _Piavca_base.SequentialChoiceMotion_getEventNames(*args)
5265 - def makeChoice(*args): return _Piavca_base.SequentialChoiceMotion_makeChoice(*args)
5266 SequentialChoiceMotion_swigregister = _Piavca_base.SequentialChoiceMotion_swigregister
5267 SequentialChoiceMotion_swigregister(SequentialChoiceMotion)
5268 SequentialChoiceMotion_castToThisType = _Piavca_base.SequentialChoiceMotion_castToThisType
5269
5271 __swig_setmethods__ = {}
5272 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5273 __setattr__ = lambda self, name, value: _swig_setattr(self, RandomChoiceMotion, name, value)
5274 __swig_getmethods__ = {}
5275 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5276 __getattr__ = lambda self, name: _swig_getattr(self, RandomChoiceMotion, name)
5277 __repr__ = _swig_repr
5279 this = _Piavca_base.new_RandomChoiceMotion(*args)
5280 try: self.this.append(this)
5281 except: self.this = this
5282 __swig_destroy__ = _Piavca_base.delete_RandomChoiceMotion
5283 __del__ = lambda self : None;
5285 """
5286 virtual Motion* Piavca::Motion::clone()=0
5287
5288 creates a copy of the motion
5289
5290
5291 """
5292 return _Piavca_base.RandomChoiceMotion_clone(*args)
5293
5294 - def getClassName(*args): return _Piavca_base.RandomChoiceMotion_getClassName(*args)
5295 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.RandomChoiceMotion_castToThisType
5296 if _newclass:castToThisType = staticmethod(_Piavca_base.RandomChoiceMotion_castToThisType)
5297 __swig_getmethods__["convertTo"] = lambda x: _Piavca_base.RandomChoiceMotion_convertTo
5298 if _newclass:convertTo = staticmethod(_Piavca_base.RandomChoiceMotion_convertTo)
5299 - def addMotion(*args): return _Piavca_base.RandomChoiceMotion_addMotion(*args)
5300 - def setProbability(*args): return _Piavca_base.RandomChoiceMotion_setProbability(*args)
5301 - def setMotionProb(*args): return _Piavca_base.RandomChoiceMotion_setMotionProb(*args)
5302 - def makeChoice(*args): return _Piavca_base.RandomChoiceMotion_makeChoice(*args)
5303 RandomChoiceMotion_swigregister = _Piavca_base.RandomChoiceMotion_swigregister
5304 RandomChoiceMotion_swigregister(RandomChoiceMotion)
5305 RandomChoiceMotion_castToThisType = _Piavca_base.RandomChoiceMotion_castToThisType
5306 RandomChoiceMotion_convertTo = _Piavca_base.RandomChoiceMotion_convertTo
5307
5309 __swig_setmethods__ = {}
5310 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5311 __setattr__ = lambda self, name, value: _swig_setattr(self, MotionGraph, name, value)
5312 __swig_getmethods__ = {}
5313 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5314 __getattr__ = lambda self, name: _swig_getattr(self, MotionGraph, name)
5315 __repr__ = _swig_repr
5317 if self.__class__ == MotionGraph:
5318 args = (None,) + args
5319 else:
5320 args = (self,) + args
5321 this = _Piavca_base.new_MotionGraph(*args)
5322 try: self.this.append(this)
5323 except: self.this = this
5324 __swig_destroy__ = _Piavca_base.delete_MotionGraph
5325 __del__ = lambda self : None;
5327 """
5328 virtual Motion* Piavca::Motion::clone()=0
5329
5330 creates a copy of the motion
5331
5332
5333 """
5334 return _Piavca_base.MotionGraph_clone(*args)
5335
5336 - def getClassName(*args): return _Piavca_base.MotionGraph_getClassName(*args)
5337 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.MotionGraph_castToThisType
5338 if _newclass:castToThisType = staticmethod(_Piavca_base.MotionGraph_castToThisType)
5339 __swig_getmethods__["convertTo"] = lambda x: _Piavca_base.MotionGraph_convertTo
5340 if _newclass:convertTo = staticmethod(_Piavca_base.MotionGraph_convertTo)
5341 - def addEvent(*args): return _Piavca_base.MotionGraph_addEvent(*args)
5342 - def addNextNode(*args): return _Piavca_base.MotionGraph_addNextNode(*args)
5343 - def handleEvent(*args): return _Piavca_base.MotionGraph_handleEvent(*args)
5344 - def canHandleEvent(*args): return _Piavca_base.MotionGraph_canHandleEvent(*args)
5345 - def makeChoice(*args): return _Piavca_base.MotionGraph_makeChoice(*args)
5347 self.this.disown()
5348 _Piavca_base.disown_MotionGraph(self)
5349 return weakref_proxy(self)
5350 - def updateListeners(*args): return _Piavca_base.MotionGraph_updateListeners(*args)
5351 MotionGraph_swigregister = _Piavca_base.MotionGraph_swigregister
5352 MotionGraph_swigregister(MotionGraph)
5353 MotionGraph_castToThisType = _Piavca_base.MotionGraph_castToThisType
5354 MotionGraph_convertTo = _Piavca_base.MotionGraph_convertTo
5355
5357 __swig_setmethods__ = {}
5358 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5359 __setattr__ = lambda self, name, value: _swig_setattr(self, PointAt, name, value)
5360 __swig_getmethods__ = {}
5361 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5362 __getattr__ = lambda self, name: _swig_getattr(self, PointAt, name)
5363 __repr__ = _swig_repr
5365 if self.__class__ == PointAt:
5366 args = (None,) + args
5367 else:
5368 args = (self,) + args
5369 this = _Piavca_base.new_PointAt(*args)
5370 try: self.this.append(this)
5371 except: self.this = this
5373 """
5374 virtual Motion* Piavca::Motion::clone()=0
5375
5376 creates a copy of the motion
5377
5378
5379 """
5380 return _Piavca_base.PointAt_clone(*args)
5381
5382 - def getClassName(*args): return _Piavca_base.PointAt_getClassName(*args)
5383 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.PointAt_castToThisType
5384 if _newclass:castToThisType = staticmethod(_Piavca_base.PointAt_castToThisType)
5386 """
5387 virtual bool Piavca::MotionFilter::isRandomAccess()
5388
5389 whether you can access a motions value at frames other than the current one
5390
5391
5392 """
5393 return _Piavca_base.PointAt_isRandomAccess(*args)
5394
5395 - def setTarget(*args): return _Piavca_base.PointAt_setTarget(*args)
5396 - def getTarget(*args): return _Piavca_base.PointAt_getTarget(*args)
5398 """
5399 void Piavca::MotionFilter::setMotion(Motion *mot)
5400
5401
5402
5403
5404 """
5405 return _Piavca_base.PointAt_setMotion(*args)
5406
5407 - def getMotion(*args): return _Piavca_base.PointAt_getMotion(*args)
5408 - def setLocal(*args): return _Piavca_base.PointAt_setLocal(*args)
5409 - def getLocal(*args): return _Piavca_base.PointAt_getLocal(*args)
5410 - def setJointId(*args): return _Piavca_base.PointAt_setJointId(*args)
5411 - def getJointId(*args): return _Piavca_base.PointAt_getJointId(*args)
5412 - def setTargetJointId(*args): return _Piavca_base.PointAt_setTargetJointId(*args)
5413 - def getTargetJointId(*args): return _Piavca_base.PointAt_getTargetJointId(*args)
5416 - def setOffset(*args): return _Piavca_base.PointAt_setOffset(*args)
5417 - def getOffset(*args): return _Piavca_base.PointAt_getOffset(*args)
5419 """
5420 virtual bool Piavca::MotionFilter::isNull(int trackId) const
5421
5422 given an iterator tests whether it actually points to anything or if its null
5423
5424
5425 """
5426 return _Piavca_base.PointAt_isNull(*args)
5427
5429 """
5430 trackType Piavca::MotionFilter::getTrackType(int trackId) const
5431
5432 get the type of the track corresponding to an iterator
5433
5434
5435 """
5436 return _Piavca_base.PointAt_getTrackType(*args)
5437
5439 """
5440 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
5441
5442 internal version of getFloatValueAtTime, to be overridden
5443
5444
5445 """
5446 return _Piavca_base.PointAt_getFloatValueAtTimeInternal(*args)
5447
5449 """
5450 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
5451
5452 internal version of getVecValueAtTime, to be overridden
5453
5454
5455 """
5456 return _Piavca_base.PointAt_getVecValueAtTimeInternal(*args)
5457
5459 """
5460 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
5461
5462 internal version of getQuatValueAtTime, to be overridden
5463
5464
5465 """
5466 return _Piavca_base.PointAt_getQuatValueAtTimeInternal(*args)
5467
5468 __swig_destroy__ = _Piavca_base.delete_PointAt
5469 __del__ = lambda self : None;
5471 self.this.disown()
5472 _Piavca_base.disown_PointAt(self)
5473 return weakref_proxy(self)
5474 PointAt_swigregister = _Piavca_base.PointAt_swigregister
5475 PointAt_swigregister(PointAt)
5476 PointAt_castToThisType = _Piavca_base.PointAt_castToThisType
5477
5479 __swig_setmethods__ = {}
5480 for _s in [ChoiceMotion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5481 __setattr__ = lambda self, name, value: _swig_setattr(self, Proxemics, name, value)
5482 __swig_getmethods__ = {}
5483 for _s in [ChoiceMotion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5484 __getattr__ = lambda self, name: _swig_getattr(self, Proxemics, name)
5485 __repr__ = _swig_repr
5487 this = _Piavca_base.new_Proxemics(*args)
5488 try: self.this.append(this)
5489 except: self.this = this
5490 __swig_destroy__ = _Piavca_base.delete_Proxemics
5491 __del__ = lambda self : None;
5493 """
5494 virtual Motion* Piavca::Motion::clone()=0
5495
5496 creates a copy of the motion
5497
5498
5499 """
5500 return _Piavca_base.Proxemics_clone(*args)
5501
5502 - def getClassName(*args): return _Piavca_base.Proxemics_getClassName(*args)
5503 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.Proxemics_castToThisType
5504 if _newclass:castToThisType = staticmethod(_Piavca_base.Proxemics_castToThisType)
5506 """
5507 virtual void Piavca::MotionFilter::load(Avatar *av)
5508
5509 called when the motion is loaded into an avatar
5510
5511
5512 """
5513 return _Piavca_base.Proxemics_load(*args)
5514
5515 - def addMotion(*args): return _Piavca_base.Proxemics_addMotion(*args)
5517 - def setDistance(*args): return _Piavca_base.Proxemics_setDistance(*args)
5518 - def getDistance(*args): return _Piavca_base.Proxemics_getDistance(*args)
5519 - def setThreshold(*args): return _Piavca_base.Proxemics_setThreshold(*args)
5520 - def getThreshold(*args): return _Piavca_base.Proxemics_getThreshold(*args)
5521 - def setAngleThreshold(*args): return _Piavca_base.Proxemics_setAngleThreshold(*args)
5522 - def getAngleThreshold(*args): return _Piavca_base.Proxemics_getAngleThreshold(*args)
5523 - def setDistanceOff(*args): return _Piavca_base.Proxemics_setDistanceOff(*args)
5524 - def getDistanceOff(*args): return _Piavca_base.Proxemics_getDistanceOff(*args)
5531 - def setLeftMotionName(*args): return _Piavca_base.Proxemics_setLeftMotionName(*args)
5532 - def getLeftMotionName(*args): return _Piavca_base.Proxemics_getLeftMotionName(*args)
5535 - def setRestMotionName(*args): return _Piavca_base.Proxemics_setRestMotionName(*args)
5536 - def getRestMotionName(*args): return _Piavca_base.Proxemics_getRestMotionName(*args)
5539 - def setTarget(*args): return _Piavca_base.Proxemics_setTarget(*args)
5540 - def getTarget(*args): return _Piavca_base.Proxemics_getTarget(*args)
5541 - def setTargetId(*args): return _Piavca_base.Proxemics_setTargetId(*args)
5542 - def refreshMotions(*args): return _Piavca_base.Proxemics_refreshMotions(*args)
5543 - def makeChoice(*args): return _Piavca_base.Proxemics_makeChoice(*args)
5544 Proxemics_swigregister = _Piavca_base.Proxemics_swigregister
5545 Proxemics_swigregister(Proxemics)
5546 Proxemics_castToThisType = _Piavca_base.Proxemics_castToThisType
5547
5549 """
5550 A motion class that makes the avatar look at a target. The avatar will turn to look at the given target with eyes, head, and body. The target can either be an avatar, an object or a vector location. see also: ZeroMotion.h
5551 """
5552 __swig_setmethods__ = {}
5553 for _s in [Motion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5554 __setattr__ = lambda self, name, value: _swig_setattr(self, ZeroMotion, name, value)
5555 __swig_getmethods__ = {}
5556 for _s in [Motion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5557 __getattr__ = lambda self, name: _swig_getattr(self, ZeroMotion, name)
5558 __repr__ = _swig_repr
5560 """
5561 Piavca::ZeroMotion::ZeroMotion(const ZeroMotion &zm)
5562
5563
5564
5565
5566 """
5567 if self.__class__ == ZeroMotion:
5568 args = (None,) + args
5569 else:
5570 args = (self,) + args
5571 this = _Piavca_base.new_ZeroMotion(*args)
5572 try: self.this.append(this)
5573 except: self.this = this
5575 """
5576 virtual Motion* Piavca::ZeroMotion::clone()
5577
5578 creates a copy of the motion
5579
5580
5581 """
5582 return _Piavca_base.ZeroMotion_clone(*args)
5583
5584 - def getClassName(*args): return _Piavca_base.ZeroMotion_getClassName(*args)
5585 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ZeroMotion_castToThisType
5586 if _newclass:castToThisType = staticmethod(_Piavca_base.ZeroMotion_castToThisType)
5588 """
5589 virtual bool Piavca::ZeroMotion::isRandomAccess()
5590
5591 whether you can access a motions value at frames other than the current one
5592
5593
5594 """
5595 return _Piavca_base.ZeroMotion_isRandomAccess(*args)
5596
5598 """
5599 virtual float Piavca::ZeroMotion::getMotionLength() const
5600
5601 returns the length of the motion
5602
5603
5604 """
5605 return _Piavca_base.ZeroMotion_getMotionLength(*args)
5606
5608 """
5609 bool Piavca::ZeroMotion::isNull(int trackId) const
5610
5611 given a track ID tests whether it actually points to anything or if its null
5612
5613
5614 """
5615 return _Piavca_base.ZeroMotion_isNull(*args)
5616
5618 """
5619 virtual trackType Piavca::ZeroMotion::getTrackType(int trackId) const
5620
5621 get the type of the track corresponding to an ID
5622
5623
5624 """
5625 return _Piavca_base.ZeroMotion_getTrackType(*args)
5626
5628 """
5629 virtual float Piavca::ZeroMotion::getFloatValueAtTimeInternal(int trackId, float time)
5630
5631 get the value of a track at a given time (only works for floats)
5632
5633
5634 """
5635 return _Piavca_base.ZeroMotion_getFloatValueAtTimeInternal(*args)
5636
5638 """
5639 virtual Vec Piavca::ZeroMotion::getVecValueAtTimeInternal(int trackId, float time)
5640
5641 get the value of a track at a given time (only works for Vecs)
5642
5643
5644 """
5645 return _Piavca_base.ZeroMotion_getVecValueAtTimeInternal(*args)
5646
5648 """
5649 virtual Quat Piavca::ZeroMotion::getQuatValueAtTimeInternal(int trackId, float time)
5650
5651 get the value of a track at a given time (only works for Quats)
5652
5653
5654 """
5655 return _Piavca_base.ZeroMotion_getQuatValueAtTimeInternal(*args)
5656
5657 __swig_destroy__ = _Piavca_base.delete_ZeroMotion
5658 __del__ = lambda self : None;
5660 self.this.disown()
5661 _Piavca_base.disown_ZeroMotion(self)
5662 return weakref_proxy(self)
5663 ZeroMotion_swigregister = _Piavca_base.ZeroMotion_swigregister
5664 ZeroMotion_swigregister(ZeroMotion)
5665 ZeroMotion_castToThisType = _Piavca_base.ZeroMotion_castToThisType
5666
5668 """
5669 see also: SubMotion.h
5670 """
5671 __swig_setmethods__ = {}
5672 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5673 __setattr__ = lambda self, name, value: _swig_setattr(self, SubMotion, name, value)
5674 __swig_getmethods__ = {}
5675 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5676 __getattr__ = lambda self, name: _swig_getattr(self, SubMotion, name)
5677 __repr__ = _swig_repr
5679 """
5680 SubMotion::SubMotion(const SubMotion &sm)
5681
5682
5683
5684
5685 """
5686 if self.__class__ == SubMotion:
5687 args = (None,) + args
5688 else:
5689 args = (self,) + args
5690 this = _Piavca_base.new_SubMotion(*args)
5691 try: self.this.append(this)
5692 except: self.this = this
5694 """
5695 Motion * SubMotion::clone()
5696
5697 creates a copy of the motion
5698
5699
5700 """
5701 return _Piavca_base.SubMotion_clone(*args)
5702
5703 - def getClassName(*args): return _Piavca_base.SubMotion_getClassName(*args)
5704 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.SubMotion_castToThisType
5705 if _newclass:castToThisType = staticmethod(_Piavca_base.SubMotion_castToThisType)
5707 """
5708 float SubMotion::getMotionLength() const
5709
5710 gets the length of the motion in seconds
5711
5712
5713 """
5714 return _Piavca_base.SubMotion_getMotionLength(*args)
5715
5717 """
5718 void SubMotion::setStart(float s)
5719
5720 Sets the start of the range to be played.
5721
5722
5723 """
5724 return _Piavca_base.SubMotion_setStart(*args)
5725
5727 """
5728 void SubMotion::setEnd(float e)
5729
5730 Sets the end of the range to be played.
5731
5732
5733 """
5734 return _Piavca_base.SubMotion_setEnd(*args)
5735
5736 - def getStart(*args): return _Piavca_base.SubMotion_getStart(*args)
5737 - def getEnd(*args): return _Piavca_base.SubMotion_getEnd(*args)
5739 """
5740 PIAVCA_EXPORT float SubMotion::getFloatValueAtTimeInternal(int trackId, float time)
5741
5742 calculates the values of a keyframe
5743
5744
5745 """
5746 return _Piavca_base.SubMotion_getFloatValueAtTimeInternal(*args)
5747
5749 """
5750 PIAVCA_EXPORT Vec SubMotion::getVecValueAtTimeInternal(int trackId, float time)
5751
5752 calculates the values of a keyframe
5753
5754
5755 """
5756 return _Piavca_base.SubMotion_getVecValueAtTimeInternal(*args)
5757
5759 """
5760 PIAVCA_EXPORT Quat SubMotion::getQuatValueAtTimeInternal(int trackId, float time)
5761
5762 calculates the values of a keyframe
5763
5764
5765 """
5766 return _Piavca_base.SubMotion_getQuatValueAtTimeInternal(*args)
5767
5768 __swig_destroy__ = _Piavca_base.delete_SubMotion
5769 __del__ = lambda self : None;
5771 self.this.disown()
5772 _Piavca_base.disown_SubMotion(self)
5773 return weakref_proxy(self)
5774 SubMotion_swigregister = _Piavca_base.SubMotion_swigregister
5775 SubMotion_swigregister(SubMotion)
5776 SubMotion_castToThisType = _Piavca_base.SubMotion_castToThisType
5777
5779 """
5780 see also: TimeRangeMotion.h
5781 """
5782 __swig_setmethods__ = {}
5783 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5784 __setattr__ = lambda self, name, value: _swig_setattr(self, TimeRangeMotion, name, value)
5785 __swig_getmethods__ = {}
5786 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5787 __getattr__ = lambda self, name: _swig_getattr(self, TimeRangeMotion, name)
5788 __repr__ = _swig_repr
5790 """
5791 TimeRangeMotion::TimeRangeMotion(const TimeRangeMotion &sm)
5792
5793
5794
5795
5796 """
5797 if self.__class__ == TimeRangeMotion:
5798 args = (None,) + args
5799 else:
5800 args = (self,) + args
5801 this = _Piavca_base.new_TimeRangeMotion(*args)
5802 try: self.this.append(this)
5803 except: self.this = this
5805 """
5806 Motion * TimeRangeMotion::clone()
5807
5808 creates a copy of the motion
5809
5810
5811 """
5812 return _Piavca_base.TimeRangeMotion_clone(*args)
5813
5814 - def getClassName(*args): return _Piavca_base.TimeRangeMotion_getClassName(*args)
5815 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.TimeRangeMotion_castToThisType
5816 if _newclass:castToThisType = staticmethod(_Piavca_base.TimeRangeMotion_castToThisType)
5818 """
5819 void TimeRangeMotion::setStart(float s)
5820
5821 Sets the start of the range to be played.
5822
5823
5824 """
5825 return _Piavca_base.TimeRangeMotion_setStart(*args)
5826
5828 """
5829 void TimeRangeMotion::setEnd(float e)
5830
5831 Sets the end of the range to be played.
5832
5833
5834 """
5835 return _Piavca_base.TimeRangeMotion_setEnd(*args)
5836
5838 """
5839 PIAVCA_EXPORT float TimeRangeMotion::getFloatValueAtTimeInternal(int trackId, float time)
5840
5841 calculates the values of a keyframe
5842
5843
5844 """
5845 return _Piavca_base.TimeRangeMotion_getFloatValueAtTimeInternal(*args)
5846
5848 """
5849 PIAVCA_EXPORT Vec TimeRangeMotion::getVecValueAtTimeInternal(int trackId, float time)
5850
5851 calculates the values of a keyframe
5852
5853
5854 """
5855 return _Piavca_base.TimeRangeMotion_getVecValueAtTimeInternal(*args)
5856
5858 """
5859 PIAVCA_EXPORT Quat TimeRangeMotion::getQuatValueAtTimeInternal(int trackId, float time)
5860
5861 calculates the values of a keyframe
5862
5863
5864 """
5865 return _Piavca_base.TimeRangeMotion_getQuatValueAtTimeInternal(*args)
5866
5867 __swig_destroy__ = _Piavca_base.delete_TimeRangeMotion
5868 __del__ = lambda self : None;
5870 self.this.disown()
5871 _Piavca_base.disown_TimeRangeMotion(self)
5872 return weakref_proxy(self)
5873 TimeRangeMotion_swigregister = _Piavca_base.TimeRangeMotion_swigregister
5874 TimeRangeMotion_swigregister(TimeRangeMotion)
5875 TimeRangeMotion_castToThisType = _Piavca_base.TimeRangeMotion_castToThisType
5876
5878 """
5879 a motion filter that scales the motion's speed
5880
5881 see also: TimeWarp.h
5882 """
5883 __swig_setmethods__ = {}
5884 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5885 __setattr__ = lambda self, name, value: _swig_setattr(self, TimeWarp, name, value)
5886 __swig_getmethods__ = {}
5887 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5888 __getattr__ = lambda self, name: _swig_getattr(self, TimeWarp, name)
5889 __repr__ = _swig_repr
5891 """
5892 Piavca::TimeWarp::TimeWarp(const TimeWarp &tw)
5893
5894
5895
5896
5897 """
5898 if self.__class__ == TimeWarp:
5899 args = (None,) + args
5900 else:
5901 args = (self,) + args
5902 this = _Piavca_base.new_TimeWarp(*args)
5903 try: self.this.append(this)
5904 except: self.this = this
5906 """
5907 virtual Motion* Piavca::TimeWarp::clone()
5908
5909 creates a copy of the motion
5910
5911
5912 """
5913 return _Piavca_base.TimeWarp_clone(*args)
5914
5915 - def getClassName(*args): return _Piavca_base.TimeWarp_getClassName(*args)
5916 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.TimeWarp_castToThisType
5917 if _newclass:castToThisType = staticmethod(_Piavca_base.TimeWarp_castToThisType)
5919 """
5920 virtual float Piavca::TimeWarp::getMotionLength() const
5921
5922 gets the length of the motion in seconds
5923
5924
5925 """
5926 return _Piavca_base.TimeWarp_getMotionLength(*args)
5927
5929 """
5930 virtual PIAVCA_EXPORT float Piavca::TimeWarp::getFloatValueAtTimeInternal(int trackId, float time)
5931
5932 calculates the values of a keyframe
5933
5934
5935 """
5936 return _Piavca_base.TimeWarp_getFloatValueAtTimeInternal(*args)
5937
5939 """
5940 virtual PIAVCA_EXPORT Vec Piavca::TimeWarp::getVecValueAtTimeInternal(int trackId, float time)
5941
5942 calculates the values of a keyframe
5943
5944
5945 """
5946 return _Piavca_base.TimeWarp_getVecValueAtTimeInternal(*args)
5947
5949 """
5950 virtual PIAVCA_EXPORT Quat Piavca::TimeWarp::getQuatValueAtTimeInternal(int trackId, float time)
5951
5952 calculates the values of a keyframe
5953
5954
5955 """
5956 return _Piavca_base.TimeWarp_getQuatValueAtTimeInternal(*args)
5957
5959 """
5960 void Piavca::TimeWarp::setWarp(Motion *warp)
5961
5962 Sets the scale factor for the postion components of the motion.
5963
5964
5965 """
5966 return _Piavca_base.TimeWarp_setWarp(*args)
5967
5968 __swig_destroy__ = _Piavca_base.delete_TimeWarp
5969 __del__ = lambda self : None;
5971 self.this.disown()
5972 _Piavca_base.disown_TimeWarp(self)
5973 return weakref_proxy(self)
5974 TimeWarp_swigregister = _Piavca_base.TimeWarp_swigregister
5975 TimeWarp_swigregister(TimeWarp)
5976 TimeWarp_castToThisType = _Piavca_base.TimeWarp_castToThisType
5977
5979 __swig_setmethods__ = {}
5980 for _s in [TwoMotionCombiner]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
5981 __setattr__ = lambda self, name, value: _swig_setattr(self, OverrideMotion, name, value)
5982 __swig_getmethods__ = {}
5983 for _s in [TwoMotionCombiner]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
5984 __getattr__ = lambda self, name: _swig_getattr(self, OverrideMotion, name)
5985 __repr__ = _swig_repr
5987 this = _Piavca_base.new_OverrideMotion(*args)
5988 try: self.this.append(this)
5989 except: self.this = this
5991 """
5992 virtual Motion* Piavca::Motion::clone()=0
5993
5994 creates a copy of the motion
5995
5996
5997 """
5998 return _Piavca_base.OverrideMotion_clone(*args)
5999
6000 - def getClassName(*args): return _Piavca_base.OverrideMotion_getClassName(*args)
6001 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.OverrideMotion_castToThisType
6002 if _newclass:castToThisType = staticmethod(_Piavca_base.OverrideMotion_castToThisType)
6004 """
6005 trackType TwoMotionCombiner::getTrackType(int trackId) const
6006
6007 get the type of the track corresponding to an iterator
6008
6009
6010 """
6011 return _Piavca_base.OverrideMotion_getTrackType(*args)
6012
6014 """
6015 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
6016
6017 internal version of getFloatValueAtTime, to be overridden
6018
6019
6020 """
6021 return _Piavca_base.OverrideMotion_getFloatValueAtTimeInternal(*args)
6022
6024 """
6025 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
6026
6027 internal version of getVecValueAtTime, to be overridden
6028
6029
6030 """
6031 return _Piavca_base.OverrideMotion_getVecValueAtTimeInternal(*args)
6032
6034 """
6035 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
6036
6037 internal version of getQuatValueAtTime, to be overridden
6038
6039
6040 """
6041 return _Piavca_base.OverrideMotion_getQuatValueAtTimeInternal(*args)
6042
6043 __swig_destroy__ = _Piavca_base.delete_OverrideMotion
6044 __del__ = lambda self : None;
6045 OverrideMotion_swigregister = _Piavca_base.OverrideMotion_swigregister
6046 OverrideMotion_swigregister(OverrideMotion)
6047 OverrideMotion_castToThisType = _Piavca_base.OverrideMotion_castToThisType
6048
6059 - def expMap(*args): return _Piavca_base.TangentSpace_expMap(*args)
6060 - def logMap(*args): return _Piavca_base.TangentSpace_logMap(*args)
6061 - def mean(*args): return _Piavca_base.TangentSpace_mean(*args)
6062 __swig_getmethods__["calculateTangentSpacesFromMotionAverages"] = lambda x: _Piavca_base.TangentSpace_calculateTangentSpacesFromMotionAverages
6063 if _newclass:calculateTangentSpacesFromMotionAverages = staticmethod(_Piavca_base.TangentSpace_calculateTangentSpacesFromMotionAverages)
6064 __swig_destroy__ = _Piavca_base.delete_TangentSpace
6065 __del__ = lambda self : None;
6066 TangentSpace_swigregister = _Piavca_base.TangentSpace_swigregister
6067 TangentSpace_swigregister(TangentSpace)
6068 TangentSpace_calculateTangentSpacesFromMotionAverages = _Piavca_base.TangentSpace_calculateTangentSpacesFromMotionAverages
6069
6071 __swig_setmethods__ = {}
6072 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
6073 __setattr__ = lambda self, name, value: _swig_setattr(self, ExpMapMotion, name, value)
6074 __swig_getmethods__ = {}
6075 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
6076 __getattr__ = lambda self, name: _swig_getattr(self, ExpMapMotion, name)
6077 __repr__ = _swig_repr
6079 if self.__class__ == ExpMapMotion:
6080 args = (None,) + args
6081 else:
6082 args = (self,) + args
6083 this = _Piavca_base.new_ExpMapMotion(*args)
6084 try: self.this.append(this)
6085 except: self.this = this
6087 """
6088 virtual Motion* Piavca::Motion::clone()=0
6089
6090 creates a copy of the motion
6091
6092
6093 """
6094 return _Piavca_base.ExpMapMotion_clone(*args)
6095
6096 - def getClassName(*args): return _Piavca_base.ExpMapMotion_getClassName(*args)
6097 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.ExpMapMotion_castToThisType
6098 if _newclass:castToThisType = staticmethod(_Piavca_base.ExpMapMotion_castToThisType)
6100 """
6101 trackType Piavca::MotionFilter::getTrackType(int trackId) const
6102
6103 get the type of the track corresponding to an iterator
6104
6105
6106 """
6107 return _Piavca_base.ExpMapMotion_getTrackType(*args)
6108
6110 """
6111 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
6112
6113 internal version of getQuatValueAtTime, to be overridden
6114
6115
6116 """
6117 return _Piavca_base.ExpMapMotion_getQuatValueAtTimeInternal(*args)
6118
6119 __swig_destroy__ = _Piavca_base.delete_ExpMapMotion
6120 __del__ = lambda self : None;
6122 self.this.disown()
6123 _Piavca_base.disown_ExpMapMotion(self)
6124 return weakref_proxy(self)
6125 ExpMapMotion_swigregister = _Piavca_base.ExpMapMotion_swigregister
6126 ExpMapMotion_swigregister(ExpMapMotion)
6127 ExpMapMotion_castToThisType = _Piavca_base.ExpMapMotion_castToThisType
6128
6130 __swig_setmethods__ = {}
6131 for _s in [MotionFilter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
6132 __setattr__ = lambda self, name, value: _swig_setattr(self, LogMapMotion, name, value)
6133 __swig_getmethods__ = {}
6134 for _s in [MotionFilter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
6135 __getattr__ = lambda self, name: _swig_getattr(self, LogMapMotion, name)
6136 __repr__ = _swig_repr
6138 if self.__class__ == LogMapMotion:
6139 args = (None,) + args
6140 else:
6141 args = (self,) + args
6142 this = _Piavca_base.new_LogMapMotion(*args)
6143 try: self.this.append(this)
6144 except: self.this = this
6146 """
6147 virtual Motion* Piavca::Motion::clone()=0
6148
6149 creates a copy of the motion
6150
6151
6152 """
6153 return _Piavca_base.LogMapMotion_clone(*args)
6154
6155 - def getClassName(*args): return _Piavca_base.LogMapMotion_getClassName(*args)
6156 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.LogMapMotion_castToThisType
6157 if _newclass:castToThisType = staticmethod(_Piavca_base.LogMapMotion_castToThisType)
6159 """
6160 trackType Piavca::MotionFilter::getTrackType(int trackId) const
6161
6162 get the type of the track corresponding to an iterator
6163
6164
6165 """
6166 return _Piavca_base.LogMapMotion_getTrackType(*args)
6167
6169 """
6170 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
6171
6172 internal version of getVecValueAtTime, to be overridden
6173
6174
6175 """
6176 return _Piavca_base.LogMapMotion_getVecValueAtTimeInternal(*args)
6177
6178 __swig_destroy__ = _Piavca_base.delete_LogMapMotion
6179 __del__ = lambda self : None;
6181 self.this.disown()
6182 _Piavca_base.disown_LogMapMotion(self)
6183 return weakref_proxy(self)
6184 LogMapMotion_swigregister = _Piavca_base.LogMapMotion_swigregister
6185 LogMapMotion_swigregister(LogMapMotion)
6186 LogMapMotion_castToThisType = _Piavca_base.LogMapMotion_castToThisType
6187
6189 __swig_setmethods__ = {}
6190 for _s in [Motion]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
6191 __setattr__ = lambda self, name, value: _swig_setattr(self, AvatarMotion, name, value)
6192 __swig_getmethods__ = {}
6193 for _s in [Motion]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
6194 __getattr__ = lambda self, name: _swig_getattr(self, AvatarMotion, name)
6195 __repr__ = _swig_repr
6197 if self.__class__ == AvatarMotion:
6198 args = (None,) + args
6199 else:
6200 args = (self,) + args
6201 this = _Piavca_base.new_AvatarMotion(*args)
6202 try: self.this.append(this)
6203 except: self.this = this
6205 """
6206 virtual Motion* Piavca::Motion::clone()=0
6207
6208 creates a copy of the motion
6209
6210
6211 """
6212 return _Piavca_base.AvatarMotion_clone(*args)
6213
6214 - def getClassName(*args): return _Piavca_base.AvatarMotion_getClassName(*args)
6215 __swig_getmethods__["castToThisType"] = lambda x: _Piavca_base.AvatarMotion_castToThisType
6216 if _newclass:castToThisType = staticmethod(_Piavca_base.AvatarMotion_castToThisType)
6218 """
6219 virtual bool Piavca::Motion::isRandomAccess()
6220
6221 whether you can access a motions value at frames other than the current one
6222
6223
6224 """
6225 return _Piavca_base.AvatarMotion_isRandomAccess(*args)
6226
6227 - def setWrappedAvatar(*args): return _Piavca_base.AvatarMotion_setWrappedAvatar(*args)
6228 - def getWrappedAvatar(*args): return _Piavca_base.AvatarMotion_getWrappedAvatar(*args)
6229 - def setGlobal(*args): return _Piavca_base.AvatarMotion_setGlobal(*args)
6230 - def getGlobal(*args): return _Piavca_base.AvatarMotion_getGlobal(*args)
6232 """
6233 virtual bool Piavca::Motion::isNull(int trackId) const =0
6234
6235 given a track ID tests whether it actually points to anything or if its null
6236
6237
6238 """
6239 return _Piavca_base.AvatarMotion_isNull(*args)
6240
6242 """
6243 virtual trackType Piavca::Motion::getTrackType(int trackId) const =0
6244
6245 get the type of the track corresponding to an ID
6246
6247
6248 """
6249 return _Piavca_base.AvatarMotion_getTrackType(*args)
6250
6252 """
6253 virtual float Piavca::Motion::getFloatValueAtTimeInternal(int trackId, float time)=0
6254
6255 internal version of getFloatValueAtTime, to be overridden
6256
6257
6258 """
6259 return _Piavca_base.AvatarMotion_getFloatValueAtTimeInternal(*args)
6260
6262 """
6263 virtual Vec Piavca::Motion::getVecValueAtTimeInternal(int trackId, float time)=0
6264
6265 internal version of getVecValueAtTime, to be overridden
6266
6267
6268 """
6269 return _Piavca_base.AvatarMotion_getVecValueAtTimeInternal(*args)
6270
6272 """
6273 virtual Quat Piavca::Motion::getQuatValueAtTimeInternal(int trackId, float time)=0
6274
6275 internal version of getQuatValueAtTime, to be overridden
6276
6277
6278 """
6279 return _Piavca_base.AvatarMotion_getQuatValueAtTimeInternal(*args)
6280
6281 __swig_destroy__ = _Piavca_base.delete_AvatarMotion
6282 __del__ = lambda self : None;
6284 self.this.disown()
6285 _Piavca_base.disown_AvatarMotion(self)
6286 return weakref_proxy(self)
6287 AvatarMotion_swigregister = _Piavca_base.AvatarMotion_swigregister
6288 AvatarMotion_swigregister(AvatarMotion)
6289 AvatarMotion_castToThisType = _Piavca_base.AvatarMotion_castToThisType
6290